sort algorithms: remove unneeded local pointer

- remove unneeded local pointer elements from sort algorithms

Author: jciberlin

Src/sort/bubble_sort.c

@@ -39,14 +39,13 @@
 void
 BubbleSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
                 bool (*compareFun)(void* first, void* second)) {
-    byte_t* elements = buffer;
     bool swapped = true;
     int32_t i = 0;
     while (swapped) {
         swapped = false;
         for (int32_t j = 0; j < (number_of_elements - i - 1); ++j) {
-            if (compareFun(&elements[j * element_size], &elements[(j + 1) * element_size])) {
-                Utils_swapElements(&elements[j * element_size], &elements[(j + 1) * element_size], (uint32_t)element_size);
+            if (compareFun(&buffer[j * element_size], &buffer[(j + 1) * element_size])) {
+                Utils_swapElements(&buffer[j * element_size], &buffer[(j + 1) * element_size], (uint32_t)element_size);
                 swapped = true;
             }
         }

Src/sort/heap_sort.c

@@ -41,28 +41,27 @@ Heapify(byte_t* buffer, int32_t n, int32_t i, int32_t element_size,
         bool (*compareFun)(void* first, void* second)) {
     bool continue_iterating = true;
     int32_t index = i;
-    byte_t* elements = buffer;
 
     while (continue_iterating) {
         int32_t largest = index;
         int32_t left = (2 * index) + 1;
         int32_t right = (2 * index) + 2;
 
-        bool compare_ret_value = compareFun(&elements[left * element_size],
-                                            &elements[largest * element_size]);
+        bool compare_ret_value = compareFun(&buffer[left * element_size],
+                                            &buffer[largest * element_size]);
 
         if ((left < n) && (compare_ret_value)) {
             largest = left;
         }
 
-        compare_ret_value = compareFun(&elements[right * element_size], &elements[largest * element_size]);
+        compare_ret_value = compareFun(&buffer[right * element_size], &buffer[largest * element_size]);
 
         if ((right < n) && (compare_ret_value)) {
             largest = right;
         }
 
         if (largest != index) {
-            Utils_swapElements(&elements[index * element_size], &elements[largest * element_size], (uint32_t)element_size);
+            Utils_swapElements(&buffer[index * element_size], &buffer[largest * element_size], (uint32_t)element_size);
             index = largest;
         } else {
             continue_iterating = false;
@@ -74,13 +73,12 @@ void
 HeapSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
               bool (*compareFun)(void* first, void* second)) {
     int32_t i;
-    byte_t* elements = buffer;
     for (i = (number_of_elements / 2) - 1; i >= 0; --i) {
-        Heapify(elements, number_of_elements, i, element_size, compareFun);
+        Heapify(buffer, number_of_elements, i, element_size, compareFun);
     }
 
     for (i = number_of_elements - 1; i >= 0; --i) {
-        Utils_swapElements(&elements[0], &elements[i * element_size], (uint32_t)element_size);
-        Heapify(elements, i, 0, element_size, compareFun);
+        Utils_swapElements(&buffer[0], &buffer[i * element_size], (uint32_t)element_size);
+        Heapify(buffer, i, 0, element_size, compareFun);
     }
 }

Src/sort/insertion_sort.c

@@ -39,21 +39,20 @@
 void
 InsertionSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
                    bool (*compareFun)(void* first, void* second)) {
-    byte_t* elements = buffer;
     static byte_t max_element[MAX_ELEMENT_SIZE];
     byte_t* element = &max_element[0];
 
     for (int32_t i = 1; i < number_of_elements; ++i) {
-        memcpy(element, &elements[i * element_size], (size_t)element_size);
+        memcpy(element, &buffer[i * element_size], (size_t)element_size);
 
         int32_t j = i - 1;
-        bool compare = compareFun(&elements[j * element_size], element);
+        bool compare = compareFun(&buffer[j * element_size], element);
 
         while ((j >= 0) && compare) {
-            memcpy(&elements[(j + 1) * element_size], &elements[j * element_size], (size_t)element_size);
+            memcpy(&buffer[(j + 1) * element_size], &buffer[j * element_size], (size_t)element_size);
             --j;
-            compare = compareFun(&elements[j * element_size], element);
+            compare = compareFun(&buffer[j * element_size], element);
         }
-        memcpy(&elements[(j + 1) * element_size], element, (size_t)element_size);
+        memcpy(&buffer[(j + 1) * element_size], element, (size_t)element_size);
     }
 }

Src/sort/merge_sort.c

@@ -39,7 +39,6 @@
 static 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;
@@ -49,11 +48,11 @@ MergeHalves(byte_t* buffer, int32_t element_size, int32_t left, int32_t mid, int
     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);
+        memcpy(&left_half[i * element_size], &buffer[(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);
+        memcpy(&right_half[j * element_size], &buffer[(mid + 1 + j) * element_size], (size_t)element_size);
     }
 
     i = 0;
@@ -63,23 +62,23 @@ MergeHalves(byte_t* buffer, int32_t element_size, int32_t left, int32_t mid, int
     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);
+            memcpy(&buffer[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);
+            memcpy(&buffer[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);
+        memcpy(&buffer[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);
+        memcpy(&buffer[k * element_size], &right_half[j * element_size], (size_t)element_size);
         ++j;
         ++k;
     }
@@ -88,7 +87,6 @@ MergeHalves(byte_t* buffer, int32_t element_size, int32_t left, int32_t mid, int
 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;
@@ -98,7 +96,7 @@ MergeSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
             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);
+            MergeHalves(buffer, element_size, left, mid, right, compareFun);
         }
     }
 }

Src/sort/selection_sort.c

@@ -39,19 +39,18 @@
 void
 SelectionSort_sort(byte_t* buffer, int32_t number_of_elements, int32_t element_size,
                    bool (*compareFun)(void* first, void* second)) {
-    byte_t* elements = buffer;
     int32_t j;
 
     for (int32_t i = 0; i < (number_of_elements - 1); ++i) {
         int32_t min_index = i;
         for (j = i + 1; j < number_of_elements; ++j) {
-            if (compareFun(&elements[min_index * element_size], &elements[j * element_size])) {
+            if (compareFun(&buffer[min_index * element_size], &buffer[j * element_size])) {
                 min_index = j;
             }
         }
 
         if (min_index != i) {
-            Utils_swapElements(&elements[min_index * element_size], &elements[i * element_size], (uint32_t)element_size);
+            Utils_swapElements(&buffer[min_index * element_size], &buffer[i * element_size], (uint32_t)element_size);
         }
     }
 }