Implement MISRA compliant merge sort

- MISRA compliant merge sort

Author: jciberlin

Inc/sort/merge_sort.h

@@ -0,0 +1,59 @@
+/****************************************************************************
+ *
+ *   Copyright (c) 2025 IMProject Development Team. All rights reserved.
+ *   Authors: Juraj Ciberlin <[email protected]>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name IMProject nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef UTILITY_MERGE_SORT_H_
+#define UTILITY_MERGE_SORT_H_
+
+#include "typedefs.h"
+
+#define MAX_HALVES_SIZE (64)
+
+/**
+ * @brief Sort elements using merge sort algorithm. Merge sort algorithm works on a principle that it
+ * divides the list/array into two halves. Sort each one. Merge them back together. Repeat the whole
+ * process until the entire array is sorted. This algorithm does not use recursion since it is not MISRA
+ * compliant.
+ * Time complexity: O(N log N)
+ *
+ * @param[in/out] *buffer Pointer to the buffer that contains elements that will be sorted.
+ * @param[in] number_of_elements Number of elements in the buffer.
+ * @param[in] element_size Size of the element, in bytes.
+ * @param[in] *compareFun Pointer to compare function. Compare function has two parameters (pointer to
+ *                        first element and pointer to second element). As a result, it returns boolean,
+ *                        true if first element is greater than second element, otherwise false.
+ */
+void MergeSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
+                    bool (*compareFun)(void* first, void* second));
+
+#endif /* UTILITY_MERGE_SORT_H_ */

Makefile

@@ -111,6 +111,7 @@ IMUTILITY_FILES=\
   Src/sort/bubble_sort.c \
   Src/sort/heap_sort.c \
   Src/sort/insertion_sort.c \
+  Src/sort/merge_sort.c \
   Src/sort/selection_sort.c \
   Src/json.c \
   Src/map.c \
@@ -136,6 +137,7 @@ SRC_FILES+=$(IMUTILITY_FILES) \
   Tests/test_insertion_sort.c \
   Tests/test_json.c \
   Tests/test_map.c \
+  Tests/test_merge_sort.c \
   Tests/test_priority_queue.c \
   Tests/test_queue.c \
   Tests/test_scheduler.c \

README.md

@@ -161,6 +161,7 @@ Join us on the Discord channel https://discord.gg/R6nZxZqDH3
 - BubbleSort_sort
 - HeapSort_sort
 - InsertionSort_sort
+- MergeSort_sort
 - SelectionSort_sort
 
 ### Utils

Src/sort/merge_sort.c

@@ -0,0 +1,104 @@
+/****************************************************************************
+ *
+ *   Copyright (c) 2025 IMProject Development Team. All rights reserved.
+ *   Authors: Juraj Ciberlin <[email protected]>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name IMProject nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#include "merge_sort.h"
+
+#include <string.h>
+
+void
+MergeHalves(byte_t* buffer, int32_t element_size, int32_t left, int32_t mid, int32_t right,
+            bool (*compareFun)(void* first, void* second)) {
+    byte_t* elements = buffer;
+    byte_t left_half[MAX_HALVES_SIZE];
+    byte_t right_half[MAX_HALVES_SIZE];
+    int32_t i;
+    int32_t j;
+    int32_t k;
+    int32_t number_of_elements_1 = mid - left + 1;
+    int32_t number_of_elements_2 =  right - mid;
+
+    for (i = 0; i < number_of_elements_1; ++i) {
+        memcpy(&left_half[i * element_size], &elements[(left + i) * element_size], (size_t)element_size);
+    }
+
+    for (j = 0; j < number_of_elements_2; ++j) {
+        memcpy(&right_half[j * element_size], &elements[(mid + 1 + j) * element_size], (size_t)element_size);
+    }
+
+    i = 0;
+    j = 0;
+    k = left;
+
+    while ((i < number_of_elements_1) && (j < number_of_elements_2)) {
+        bool compare = compareFun(&right_half[j * element_size], &left_half[i * element_size]);
+        if (compare) {
+            memcpy(&elements[k * element_size], &left_half[i * element_size], (size_t)element_size);
+            ++i;
+        } else {
+            memcpy(&elements[k * element_size], &right_half[j * element_size], (size_t)element_size);
+            ++j;
+        }
+        ++k;
+    }
+
+    while (i < number_of_elements_1) {
+        memcpy(&elements[k * element_size], &left_half[i * element_size], (size_t)element_size);
+        ++i;
+        ++k;
+    }
+
+    while (j < number_of_elements_2) {
+        memcpy(&elements[k * element_size], &right_half[j * element_size], (size_t)element_size);
+        ++j;
+        ++k;
+    }
+}
+
+void
+MergeSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
+               bool (*compareFun)(void* first, void* second)) {
+    byte_t* elements = buffer;
+    for (int32_t current_size = 1; current_size <= number_of_elements - 1; current_size *= 2) {
+        for (int32_t left = 0; left < number_of_elements - 1; left += (2 * current_size)) {
+            int32_t compare_first_1 = left + current_size - 1;
+            int32_t compare_second = number_of_elements - 1;
+            int32_t mid = (compare_first_1 < compare_second) ? compare_first_1 : compare_second;
+
+            int32_t compare_first_2 = left + (2 * current_size) - 1;
+            int32_t right = (compare_first_2 < compare_second) ? compare_first_2 : compare_second;
+
+            MergeHalves(elements, element_size, left, mid, right, compareFun);
+        }
+    }
+}

Tests/test_main.c

@@ -15,6 +15,7 @@ RunAllTests(void) {
     RUN_TEST_GROUP(InsertionSort);
     RUN_TEST_GROUP(Json);
     RUN_TEST_GROUP(Map);
+    RUN_TEST_GROUP(MergeSort);
     RUN_TEST_GROUP(PriorityQueue);
     RUN_TEST_GROUP(Queue);
     RUN_TEST_GROUP(Scheduler);

Tests/test_merge_sort.c

@@ -0,0 +1,53 @@
+#include "merge_sort.h"
+
+#include "unity.h"
+#include "unity_fixture.h"
+
+#include "helper/sort_functions.h"
+
+TEST_GROUP(MergeSort);
+
+TEST_SETUP(MergeSort) {
+}
+
+TEST_TEAR_DOWN(MergeSort) {
+}
+
+TEST_GROUP_RUNNER(MergeSort) {
+    RUN_TEST_CASE(MergeSort, MergeSort_int32);
+    RUN_TEST_CASE(MergeSort, MergeSort_float64);
+    RUN_TEST_CASE(MergeSort, MergeSort_uint64);
+}
+
+TEST(MergeSort, MergeSort_int32) {
+    int32_t unsorted_array[] = {5, 2, 3, 1000000, 9, 10, 11, 8, 9, 100};
+    const int32_t sorted_array[] = {2, 3, 5, 8, 9, 9, 10, 11, 100, 1000000};
+    MergeSort_sort((byte_t*)unsorted_array, sizeof(unsorted_array) / sizeof(unsorted_array[0]), sizeof(unsorted_array[0]),
+                   CompareInt32);
+
+    for (uint32_t i = 0U; i < (sizeof(unsorted_array) / sizeof(unsorted_array[0])); ++i) {
+        TEST_ASSERT_EQUAL_INT32(sorted_array[i], unsorted_array[i]);
+    }
+}
+
+TEST(MergeSort, MergeSort_float64) {
+    float64_t unsorted_array[] = {5.8, 2.2, 3.1, 1.1, 9.1, 10.3, 11.2, 8.4, 9.2, 100.9};
+    const float64_t sorted_array[] = {1.1, 2.2, 3.1, 5.8, 8.4, 9.1, 9.2, 10.3, 11.2, 100.9};
+    MergeSort_sort((byte_t*)unsorted_array, sizeof(unsorted_array) / sizeof(unsorted_array[0]), sizeof(unsorted_array[0]),
+                   CompareFloat64);
+
+    for (uint32_t i = 0U; i < (sizeof(unsorted_array) / sizeof(unsorted_array[0])); ++i) {
+        TEST_ASSERT_EQUAL_DOUBLE(sorted_array[i], unsorted_array[i]);
+    }
+}
+
+TEST(MergeSort, MergeSort_uint64) {
+    uint64_t unsorted_array[] = {1111111U, 55555555U, 44444U, 10000000000000U, 212121U, 1111U, 1U, 2U, 5U, 3U};
+    const uint64_t sorted_array[] = {1U, 2U, 3U, 5U, 1111U, 44444U, 212121U, 1111111U, 55555555U, 10000000000000U};
+    MergeSort_sort((byte_t*)unsorted_array, sizeof(unsorted_array) / sizeof(unsorted_array[0]), sizeof(unsorted_array[0]),
+                   CompareUint64);
+
+    for (uint32_t i = 0U; i < (sizeof(unsorted_array) / sizeof(unsorted_array[0])); ++i) {
+        TEST_ASSERT_EQUAL_UINT64(sorted_array[i], unsorted_array[i]);
+    }
+}