This is basically what im working with.

So far:

It takes a file name in from the command line.

Inserts it into an array.

Runs the array through various sorts.

End Result:

I'm wanting to be able to count the number of comparisons that take place in each sort function and output them to the user. Some functions I have tried to implement a comparison counter but I dont think im doing this right??

I also want to output the sorted array to a file. However im wanting to use the input filename + a suffix. Could this be done in a seperate output() function by passing the sorted array, I guess i dont know how to keep track of the input filename to use it in the output name??

I am planning on using integer data files but inserting them into an array once as integers and then a second time as integers as strings. Then performing sort on both, I guess this mean I need to change the sorting algorithms and use compare() where needed??

Here is what I have so far... any design tips, hints, points, anything would be appreciated. There is no specific question here, just a little collaboration on how I am doing so far. Thanks.

#include <iostream>

#include <string.h>

#include <fstream>

using namespace std;

void compare(int a, int b) {

// will compare the integers here and return result

}

void compare(char* a, char* b) {

// will compare here also, except as integer strings

}

template <class T>

void InsertionSort(T A[], int size)

{

int compares = 0;

for(int j=1; j<size; j++)

{

T key = A[j];

int i = j - 1;

while ((i >= 0) && (A[i] > key))

{

A[i+1] = A[i];

i -= 1;

compares++;

}

A[i+1] = key;

}

}

template <class T>

void mergesort(T A[], int left, int right)

{

if(left<right)

{

int mid=(left + right)/2;

mergesort(A, left, mid);

mergesort(A, mid+1, right);

merge(A,left,right);

}

}

template <class T>

void merge(T A[],int left, int right)

{

int size=right-left+1,

mid=(left+right)/2;

T *b=new T[size];

int count=0;

for(int x=left;x<=mid;x++,count++)

{

b[count]=A[x];

}

for(int x=right;x>=mid+1;x--,count++)

{

b[count]=A[x];

}

for(int x=0,y=size-1,put=left;x<=y;put++)

{

if(b[x]<=b[y])

{

A[put]=b[x];

x++;

}

else

{

A[put]=b[y];

y--;

}

}

delete[] b;

}

template <class T>

void quicksort(T A[], int left, int right, int pivot)

{

int left_side, right_side;

left_side = left;

right_side = right;

do

{

while (A[right_side] > pivot)

right_side--;

while (A[left_side] < pivot)

left_side++;

if (left_side <= right_side)

{

swap(A[left_side], A[right_side]);

left_side++;

right_side--;

}

}

while (right_arrow >= left_arrow);

if (left < right_arrow)

quick_sort(A, left, right_arrow);

if (left_arrow < right)

quick_sort(A, left_arrow, right);

}

template <class T>

void Heapsort(T A[], int size)

{

BuildHeap(A, size);

for(i=size; i>1; i--)

{

int tmp = A[0];

A[0] = A[i-1];

A[i-1] = tmp;

size--;

Heapify(A, 1, size);

}

}

template <class T>

void BuildHeap(T A[], int size)

{

for(i=size/2; i>0; i--)

Heapify(A, i, size);

}

template <class T>

void Heapify(T A[], int i, int size)

{

int l = 2 * i;

int r = 2 * i + 1;

int largest = 0;

if(l <= heapsize && A[l-1] > A[i-1])

largest = l;

else

largest = i;

if(r <= heapsize && A[r-1] > A[largest-1])

largest = r;

if(largest != i)

{

int tmp = A[i-1];

A[i-1] = A[largest-1];

A[largest-1] = tmp;

Heapify(A, largest, heapsize);

}

}

int main(int argc, char* argv[])

{

ifstream input; // initializes input

int dataLength;

if(argc > 1)

{

string inData = argv[1];

input.open(inData);

if (!input) {

cerr << "Unable to open file." << endl;

exit (1);

}

input >> itemCount;

arraySize=itemCount-1;

int Array[arraySize];

int arrayCount = 0;

while(input >> x) {

Array[arrayCount] = x;

arrayCount++;

}

intertionsort(Array, arraySize);

mergesort(Array, 0, arraySize);

int lastPivot = Array[arraySize];

int middlePivot = Array[arraySize]/2;

quicksort(Array, 0, arraySize, lastPivot);

quicksort(Array, 0, arraySize, middlePivot);

heapsort(Array, arraySize);

}

}

#include <string>

#include <iostream>

using namespace std;

template <class T>

bool equals(const T &A, const T &B)

{

return (A == B);

}

int main(int argc, char **argv)

{

int x = 10, y = 11;

string a = "Hello", b="Hello", c="Goodbye";

string Spc=" ";

string Not="!";

cout << (equals(x, x) ? " " : "!") << "equals(x, x)" << endl;

cout << (equals(x, y) ? " " : "!") << "equals(x, y)" << endl;

cout << (equals(a, b) ? " " : "!") << "equals(a, b)" << endl;

cout << (equals(a, c) ? " " : "!") << "equals(a, c)" << endl;

cout << (equals(x, 13) ? " " : "!") << "equals(x, 13)" << endl;

} /** End of main **/

Now, your observation that you need two comparison functions makes sense and this program has two equals() functions, one for int and one for std::string. They were written by the compiler when the templated funciton was instantiated. Since your sort functions are templated (there are really two sort functions, one for each of two types), templating the counted comparison function seems to fit in with the same spirit.

-bcl