Using this code, how could I implement a main function that would take a .txt file called 'data.txt' that i filled with only numbers be executed in each one.

I also need it to output the execution time for each individual sorting method I used.

My code:

#include #include #include #include #include

using namespace std;

int main()

{

return 0;

}

template

void insertionSort(vector & a)

{

for (int p = 1; p < a.size(); p++)

{

Comparable tmp = a[p];

int j;

for (j = p; j > 0 && tmp < a[j - 1]; j--)

a[j] = a[j - 1];

a[j] = tmp;

}

}

template

void heapsort(vector & a)

{

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

percDown(a, i, a.size());

for (int j = a.size() - 1; j > 0; j--)

{

swap(a[0], a[j]);

percDown(a, 0, j);

}

}

inline int leftChild(int i)

{

return 2 * i + 1;

}

template

void percDown(vector & a, int i, int n)

{

int child;

Comparable tmp;

for (tmp = a[i]; leftChild(i) < n; i = child)

{

child = leftChild(i);

if (child != n - 1 && a[child] < a[child + 1])

child++;

if (tmp < a[child])

a[i] = a[child];

else

break;

}

a[i] = tmp;

}

template

void mergeSort(vector & a)

{

vector tmpArray(a.size());

mergeSort(a, tmpArray, 0, a.size() - 1);

}

template

void mergeSort(vector & a,

vector & tmpArray, int left, int right)

{

if (left < right)

{

int center = (left + right) / 2;

mergeSort(a, tmpArray, left, center);

mergeSort(a, tmpArray, center + 1, right);

merge(a, tmpArray, left, center + 1, right);

}

}

template

void merge(vector & a, vector & tmpArray,

int leftPos, int rightPos, int rightEnd)

{

int leftEnd = rightPos - 1;

int tmpPos = leftPos;

int numElements = rightEnd - leftPos + 1;

while (leftPos <= leftEnd && rightPos <= rightEnd)

if (a[leftPos] <= a[rightPos])

tmpArray[tmpPos++] = a[leftPos++];

else

tmpArray[tmpPos++] = a[rightPos++];

while (leftPos <= leftEnd)

tmpArray[tmpPos++] = a[leftPos++];

while (rightPos <= rightEnd)

tmpArray[tmpPos++] = a[rightPos++];

for (int i = 0; i < numElements; i++, rightEnd--)

a[rightEnd] = tmpArray[rightEnd];

}

template

void quicksort(vector & a)

{

quicksort(a, 0, a.size() - 1);

}

template

inline void swap(Comparable & obj1, Comparable & obj2)

{

Comparable tmp = obj1;

obj1 = obj2;

obj2 = tmp;

}

template

const Comparable & median3(vector & a, int left, int right)

{

int center = (left + right) / 2;

if (a[center] < a[left])

swap(a[left], a[center]);

if (a[right] < a[left])

swap(a[left], a[right]);

if (a[right] < a[center])

swap(a[center], a[right]);

swap(a[center], a[right - 1]);

return a[right - 1];

}

template

void quicksort(vector & a, int left, int right)

{

if (left + 10 <= right)

{

Comparable pivot = median3(a, left, right);

int i = left, j = right - 1;

for (;;)

{

while (a[++i] < pivot) {}

while (pivot < a[--j]) {}

if (i < j)

swap(a[i], a[j]);

else

break;

}

swap(a[i], a[right - 1]);

quicksort(a, left, i - 1);

quicksort(a, i + 1, right);

}

else

insertionSort(a, left, right);

}

template

void insertionSort(vector & a, int left, int right)

{

for (int p = left + 1; p <= right; p++)

{

Comparable tmp = a[p];

int j;

for (j = p; j > left && tmp < a[j - 1]; j--)

a[j] = a[j - 1];

a[j] = tmp;

}

}

template

void quickSelect(vector & a, int k)

{

quickSelect(a, 0, a.size() - 1, k);

}

template

void quickSelect(vector & a, int left, int right, int k)

{

if (left + 10 <= right)

{

Comparable pivot = median3(a, left, right);

int i = left, j = right - 1;

for (;;)

{

while (a[++i] < pivot) {}

while (pivot < a[--j]) {}

if (i < j)

swap(a[i], a[j]);

else

break;

}

swap(a[i], a[right - 1]);

if (k <= i)

quickSelect(a, left, i - 1, k);

else if (k > i + 1)

quickSelect(a, i + 1, right, k);

}

else

insertionSort(a, left, right);

}

template

class Pointer

{

public:

Pointer(Comparable *rhs = NULL) : pointee(rhs) { }

bool operator<(const Pointer & rhs) const

{

return *pointee < *rhs.pointee;

}

operator Comparable * () const

{

return pointee;

}

private:

Comparable *pointee;

};

template

void largeObjectSort(vector & a)

{

vector > p(a.size());

int i, j, nextj;

for (i = 0; i < a.size(); i++)

p[i] = &a[i];

quicksort(p);

for (i = 0; i < a.size(); i++)

if (p[i] != &a[i])

{

Comparable tmp = a[i];

for (j = i; p[j] != &a[i]; j = nextj)

{

nextj = p[j] - &a[0];

a[j] = *p[j];

p[j] = &a[j];

}

a[j] = tmp;

p[j] = &a[j];

}

}

template

void shellsort(vector & a)

{

for (int gap = a.size() / 2; gap > 0; gap /= 2)

for (int i = gap; i < a.size(); i++)

{

Comparable tmp = a[i];

int j = i;

for (; j >= gap && tmp < a[j - gap]; j -= gap)

a[j] = a[j - gap];

a[j] = tmp;

}

}