Question

My code is not doing what I want it to do and I can't seem to figure out why it's not working. I commented some of the code to give some context to what I'm trying to do. Can someone check to see where my code is off. I'm assuming that I didn't use the counters properly or I'm using the pointers incorrectly. I can only use pointers to do this by the way.

Code:

#include <iostream>

using namespace std;

const int LEFT_SIZE = 8;
const int RIGHT_SIZE = 9;

void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size);
void test_Union();

int main()
{
test_Union();

return 0;
}

void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size)
{
int* walker1;
int* walker2;
int* walker3;
int count = 0; //counter to break while loop
int counter1 = 0; //counter1 counts up the size of the left array
int counter2 = 0; //counter2 counts up the size of the right array

walker1 = left; //points at left array
walker2 = right; //points at right array
walker3 = result; //points at result array (empty array gets filled up by left and right array)

while(count < left_size || count < right_size)
{
if(*walker1 < *walker2)
{
*walker3 = *walker1;
walker1++;
walker3++;
counter1++;
result_size = counter1; //result_size goes up by 1 when value in left array is smaller than right array
}
else if(*walker1 > *walker2)
{
*walker3 = *walker2;
walker2++;
walker3++;
counter2++;
result_size = counter2; //result_size goes up by 1 when value in right array is smaller than left array
}
else
{
*walker3 = *walker1;
walker1++;
walker2++;
walker3++;
result_size = counter1++; //result_size goes up by 1 when the left and right array have same number
}
count++;
}

while(counter1 < *(walker1 + counter1))
{
result_size = counter1++; //result_size is getting the remaining size of the left array
}

while(counter2 < *(walker2 + counter2))
{
result_size = counter2++; //result_size is getting the remaining size of the right array
}
}

void test_Union() //this function prints out the union array(the result array)
{
int* walker;
int left[] = {5, 10, 15, 20, 25, 30, 35, 40};
int right[] = {3, 10, 13, 20, 23, 28, 30, 33, 35};
int unionArr[0];
int totalSize = 0;

walker = unionArr;
Union(left, LEFT_SIZE, right, RIGHT_SIZE, unionArr, totalSize);
for(int i = 0; i < totalSize; i++)
{
cout << *walker << " ";
walker++;
}
}

Answer 1

#include <iostream> using namespace std; const int LEFT_SIZE = 8; const int RIGHT_SIZE = 9; void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size); void test_Union(); Gint main() test_Union(); return 0; void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size) 1{ int* walker1; int* walker2; int* walker3; int count = 0; //counter to break while loop int counter1 = 0; //counter1 counts up the size of the left array int counter2 = 0; //counter2 counts up the size of the right array walker1 = left; //points at left array walker2 = right; //points at right array walker3 = result; //points at result array (empty array gets filled up by left and right array) // We exit this loop once no element is remaining in any array for comparison while (counteri < left_size && counter2 < right_size) if (*walker1 < *walker2) *walker3 = *walker1; walker1++; walker3++; counter1++; result_size++; //result_size goes up by 1 when value in left array is smaller than right array

+1 else if (*walker1 > *walker2) *walker3 = *walker2; walker2++; walker3++; counter2++; result_size++; //result_size goes up by 1 when value in right array is smaller than left array else *walker3 = *walker1; walker1++; walker2++; walker3++; counter1++; counter2++; result_size++; //result_size goes up by 1 when the left and right array have same number while (counter1 < LEFT_SIZE) // Now remaining elements of First array *walker3 = *walker1; counter1++; walker1++; walker3++; result_size++; //result_size is getting the remaining size of the left array while (counter2 < RIGHT_SIZE) // Now remaining elements of First array *walker3 = *walker2; counter2++; walker2++; walker3++; result_size++; //result_size is getting the remaining size of the right array

void test_Union() //this function prints out the union array(the result array) int* walker; int left[] = { 5, 10, 15, 20, 25, 30, 35, 40 }; int right[] = { 3, 10, 13, 20, 23, 28, 30, 33, 35 }; // Maximum size of union array can be equal to sum of both array sizes if both have unique elements int *unionArr = (int*) malloc((LEFT_SIZE+RIGHT_SIZE)*sizeof(int)); memset(unionArr, -1, LEFT_SIZE + RIGHT_SIZE); // initializing final array int totalsize = 0; walker = unionArr; Union(left, LEFT_SIZE, right, RIGHT_SIZE, unionArr, totalSize); for (int i = 0; i < totalSize; i++) cout << *walker << " "; walker++;

Code

#include <iostream>

using namespace std;

const int LEFT_SIZE = 8;
const int RIGHT_SIZE = 9;

void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size);
void test_Union();

int main()
{
   test_Union();

   return 0;
}

void Union(int left[], int left_size, int right[], int right_size, int result[], int& result_size)
{
   int* walker1;
   int* walker2;
   int* walker3;
   int count = 0; //counter to break while loop
   int counter1 = 0; //counter1 counts up the size of the left array
   int counter2 = 0; //counter2 counts up the size of the right array

   walker1 = left; //points at left array
   walker2 = right; //points at right array
   walker3 = result; //points at result array (empty array gets filled up by left and right array)

   // We exit this loop once no element is remaining in any array for comparison
   while (counter1 < left_size && counter2 < right_size)
   {
       if (*walker1 < *walker2)
       {
           *walker3 = *walker1;
           walker1++;
           walker3++;
           counter1++;
           result_size++; //result_size goes up by 1 when value in left array is smaller than right array
       }
       else if (*walker1 > *walker2)
       {
           *walker3 = *walker2;
           walker2++;
           walker3++;
           counter2++;
           result_size++; //result_size goes up by 1 when value in right array is smaller than left array
       }
       else
       {
           *walker3 = *walker1;
           walker1++;
           walker2++;
           walker3++;
           counter1++;
           counter2++;
           result_size++; //result_size goes up by 1 when the left and right array have same number
       }
   }

   while (counter1 < LEFT_SIZE) // Now remaining elements of First array
   {
       *walker3 = *walker1;
       counter1++;
       walker1++;
       walker3++;
       result_size++; //result_size is getting the remaining size of the left array
   }

   while (counter2 < RIGHT_SIZE) // Now remaining elements of First array
   {
       *walker3 = *walker2;
       counter2++;
       walker2++;
       walker3++;
       result_size++; //result_size is getting the remaining size of the right array
   }
}

void test_Union() //this function prints out the union array(the result array)
{
   int* walker;
   int left[] = { 5, 10, 15, 20, 25, 30, 35, 40 };
   int right[] = { 3, 10, 13, 20, 23, 28, 30, 33, 35 };

   // Maximum size of union array can be equal to sum of both array sizes if both have unique elements
   int *unionArr = (int*)malloc((LEFT_SIZE+RIGHT_SIZE)*sizeof(int));
   memset(unionArr, -1, LEFT_SIZE + RIGHT_SIZE); // initializing final array

   int totalSize = 0;

   walker = unionArr;
   Union(left, LEFT_SIZE, right, RIGHT_SIZE, unionArr, totalSize);
   for (int i = 0; i < totalSize; i++)
   {
       cout << *walker << " ";
       walker++;
   }
}

Output

B5 19 13 15 20 23 25 28 30 33 35 40