Visual C++ Merge Sort - arrays

Question

I'm trying to figure out why the following code does not do a merge sort. The code compiles fine and there are no runtime errors. SortCollection method just returns an unsorted array. No compile errors and no run time errors, just returns an unsorted array. Any pointers would be greatly appreaciated.
#include "stdafx.h"
#include <deque>
#include <climits>
#include <stdio.h>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
generic <typename T> where T: IComparable<T>
ref class MergeSort
{
public:
// constructor
MergeSort(){}
// SortCollection() method
array<T>^ SortCollection(array<T>^ inputArray)
{
int n = inputArray->Length;
if (n <= 1)
{
return inputArray;
}
array<T>^ array1 = gcnew array<T>(inputArray->Length / 2);
array<T>^ array2 = gcnew array<T>(inputArray->Length - array1->Length);
int array1Count = 0;
int array2Count = 0;
for (int i = 0; i < n; i++)
{
if (i < n / 2)
{
array1[array1Count] = inputArray[i];
array1Count++;
}
else
{
array2[array2Count] = inputArray[i];
array2Count++;
}
}
SortCollection(array1);
SortCollection(array2);
array<T>^ newArray = gcnew array<T>(inputArray->Length);
delete inputArray;
return Merge(newArray, array1, array2);
}
array<T>^ Merge(array<T>^ targetArray, array<T>^ array1, array<T>^ array2)
{
int n1 = array1->Length;
int n2 = array2->Length;
int x1 = 0;
int x2 = 0;
int counter = 0;
while (x1 < n1 && x2 < n2)
{
if (array1[x1]->CompareTo(array2[x2]) < 0)
{
targetArray[counter] = array1[x1];
x1 ++;
counter++;
}
else
{
targetArray[counter] = array2[x2];
x2 ++;
counter++;
}
}
while (x1 < n1)
{
targetArray[counter] = array1[x1];
counter ++;
x1 ++;
}
while (x2 < n2)
{
targetArray[counter] = array2[x2];
counter ++;
x2 ++;
}
return targetArray;
}
};

Answer 1

Hmm... but what are you printing/testing? The original array or what Sort return?
Anyway, try this:
SortCollection(array1);
SortCollection(array2);
// array<T>^ newArray = gcnew array<T>(inputArray->Length);
// delete inputArray; ---> "reuse" the input array
return Merge(inputArray, array1, array2);
EDIT:
I’m sure you know this, but you just need to paid more attention to it.
A „Normal“ function take arguments and return a result, without changing the arguments:
Y=f(x);
You expect x to be as previous, and the result in y. These are the good function. But some function will change the argument. Sometime it is evident, like in
Destroy(x);
but oft is not very evident, like in
y=sort(x);
Passing x “by value” is a guaranty not to be change, but if the function take a kind of reference (like type^ x) it have direct access to the original variable and can change its contents. This duality is what you have (in SortCollection and in Merge). You need to decide, and “document” what your function return and how modify the arguments it take.
In one version (with delete) you modify the argument deleting it!!! This is normally not a good idea and has to be very good documented. And the sorted array is passed as a “return value” (a sort of reference too, really). This version modifies the argument but the result is in the return (and that is what you need to use/test/print).
The version without the delete modifies the argument, by putting the sorted array in it. In this case it could be perfectly what you want. Anyway – document it! It returns a reference to the sorted array too, -to the argument. It is done for convenience, but can be exclude for better readability, and “return” just void.
A third variant could be, not modify the argument, and return the sorted array.

Answer 2

Here you have a problem:
SortCollection(array1); // array1 is deleted??
SortCollection(array2); // you dont use any result from here?
array<T>^ newArray = gcnew array<T>(inputArray->Length);
delete inputArray; // sort, deleted input array !
return Merge(newArray, array1, array2);
Is here correct??
array1=SortCollection(array1);
array2=SortCollection(array2);
array<T>^ newArray = gcnew array<T>(inputArray->Length);
delete inputArray;
return Merge(newArray, array1, array2);