About the dynamic memory allocation for arrays in C language - c

Question

What I want to achieve is to create a merged array of two sorted arrays, such as [0, 1, 2, 3, 4] + [2, 4, 6, 8, 10] => [0, 1, 2, 2, 3, 4, 4, 8, 10], by comparing the two elements in each array
And I am trying to apply such algorithm to dynamically allocated arrays and throwing pointer arguments to custom-made merge() function. Please refer to the following excerpt
int* merge(int*, int*);
int main(int argc, const char * argv[]) {
int* arrayA;
int* arrayB;
int* mergedArray;
int index;
arrayA = (int*) malloc(sizeof(int) * 5);
arrayB = (int*) malloc(sizeof(int) * 5);
//filling out the array A with number elements like [0, 1, 2, 3, 4]
for(index = 0; index < 5; index++){
*(arrayA + sizeof(int) * index) = index;
printf("%d", *(arrayA + sizeof(int) * index));
}
//filling out the array A with number elements like [2, 4, 6, 8, 10]
for(index = 0; index < 5; index++){
*(arrayB + sizeof(int) * index) = (index + 1) * 2;
printf("%d", *(arrayB + sizeof(int) * index));
}
printf("\n");
mergedArray = (int *) merge(arrayA, arrayB);
for(index = 0; index < 10; index++){
printf("%d", *(mergedArray + sizeof(int) * index));
}
return 0;
}
The merge functions is as follows
//My take on merge() function
int *merge(int *arrayA, int *arrayB) {
int *mergedArray;
int i = 0, j = 0, k = 0; // i for arrayA / j for arrayB / k for mergedArray
int arrayALength;
int arrayBLength;
mergedArray = (int *)malloc(sizeof(int) * 10);
arrayALength = 5;
arrayBLength = 5;
while (i < arrayALength && j < arrayBLength) {
printf("%d / %d\n", *(arrayA + (i) * sizeof(int)), *(arrayB + (j) * sizeof(int)));
if (*(arrayA + (sizeof(int) * i)) < *(arrayB + (sizeof(int) * j))) {
*(mergedArray + (k++ * sizeof(int))) = *(arrayA + (i++ * sizeof(int)));
printf("%d", *(mergedArray + (k - 1) * sizeof(int)));
} else {
*(mergedArray + (k++ * sizeof(int))) = *(arrayB + (j++ * sizeof(int)));
printf("%d", *(mergedArray + (k - 1) * sizeof(int)));
}
printf("\n");
}
for (; i < arrayALength; i++) {
*(mergedArray + (k++ * sizeof(int))) = *(arrayA + (i * sizeof(int)));
}
for (; j < arrayBLength; j++) {
*(mergedArray + (k++ * sizeof(int))) = *(arrayB + (j * sizeof(int)));
}
return mergedArray;
}
The result is...
01234
246810
0 / 2
0
1 / 2
1
2 / 2
2
2 / 4
2
4 / 4
4
4 / 0
0
4 / 1
1
4 / 2
2
0122401240Program ended with exit code: 0
If you take a look at the first line "01234" in the result, I am pretty confident that [0, 1, 2, 3, 4] is stored inside the memory where arrayA is pointing at, yet inside the merge() function if I print the corresponding element, it shows [0, 1, 2, 4], leaving out the element '3' in the middle.
Not only that the program's final result "0122401240" does show that there is logic fallacy in my code, which I could not find.
If you could see the logical error, please do not hesitate to point out one, and could you tell me why there was difference in elements in allocated memory?

Answer 1

Your code is really complex, you could simplify it a lot
A way to solve your issue is to make these two arrays contiguous so that you can handle it like a single array as shown in the code below
#include <stdlib.h>
#include <stdio.h>
int mysort(const void* a, const void* b){
return (*(int*)a-*(int*)b);
}
int main(){
int sz1= 5, sz2=5;
int* arr1 = malloc((sz1+sz2)*sizeof(int)); // Allocate for both arrays
int* arr2 = &arr1[sz1]; // Go to the 2nd array
my_fill(arr1); // Setup your arrays as you wish
my_fill(arr2);
qsort(arr1, sz1+sz2, sizeof(int), mysort); // Sort both arrays using the standard qsort.
}
Obviously, if you want to use a custom sorting algorithm such as merge sort, this is possible. You can replace qsort with your custom algorithm.

Answer 2

Your code should benefit from the fact that the input arrays are already sorted. Simply take the smallest value and copy it to the output array. For each input array maintain an index that tells you where the next unused element is.
Like:
#include <stdio.h>
#include <stdlib.h>
int* mergeSortedArraysToSingleSortedArray(int* arrA, size_t szA, int* arrB, size_t szB)
{
int* res = malloc((szA + szB) * sizeof *arrA);
if (res == NULL) return NULL;
size_t iA = 0;
size_t iB = 0;
size_t i = 0;
// Merge from A and B
while (iA < szA && iB < szB)
{
if (arrA[iA] <= arrB[iB])
{
res[i] = arrA[iA];
++iA;
}
else
{
res[i] = arrB[iB];
++iB;
}
++i;
}
// Take rest of A (if any)
while (iA < szA)
{
res[i] = arrA[iA];
++iA;
++i;
}
// Take rest of B (if any)
while (iB < szB)
{
res[i] = arrB[iB];
++iB;
++i;
}
return res;
}
int main(void)
{
int arrA[] = {0, 1, 2, 3, 4};
int arrB[] = {2, 4, 6, 8, 10};
size_t szA = sizeof(arrA)/sizeof(*arrA);
size_t szB = sizeof(arrB)/sizeof(*arrB);
int* arrMerged = mergeSortedArraysToSingleSortedArray(arrA, szA, arrB, szB);
if (arrMerged)
{
for (size_t i = 0; i < szA + szB; ++i)
{
printf("%d ", arrMerged[i]);
}
printf("\n");
}
return 0;
}
Output:
0 1 2 2 3 4 4 6 8 10