Comparing Merge and Heap Sorts

[Indianna32]

I am trying to compare the heap and merge sort using their runtimes and have the program all created. However, the final data I receive, sending to a new file, just does not make sense to me. Maybe I have just been staring at this for too long but I cannot seem to figure out what is the issue. Thank you in advance

#include <iostream>
#include <math.h>
#include <chrono>
#include <ctime>
#include <vector>
#include <cstdlib>

using namespace std;

inline int parent(int i) {return ((i - 1) / 2);}
inline int LEFT(int i)   {return (2 * i + 1);}
inline int RIGHT(int i)  {return (2 * i + 2);}

void merge(int list[], int p, int q, int r)
{
	int n1=q-p+1;
	int n2=r-q;

	int L[n1+1];
	int R[n2+1];
	for(int i=0;i<n1; i++)
	{
    	L[i]=list[p+i];
	}
	for(int j=0;j<n2; j++)
	{
    	R[j]=list[q+1+j];
	}

	int largest;
	if(L[n1-1]<R[n2-1]) largest=R[n2-1]; 
	else largest=L[n1-1];
	
	L[n1]=largest+1;
	R[n2]=largest+1;

	int i=0;
	int j=0;
	for(int k=p; k<=r; k++)
	{
	    if (L[i]<=R[j])
	    {
		    list[k]=L[i];
    		i++;
    	} 
		else
    	{
    		list[k]=R[j];
    		j++;
    	}
	}
}

void merge_sort_aux(int list[], int p, int r)
{
	if(p<r)
	{
	    int q=floor((p+r)/2);
	    merge_sort_aux(list,p,q);
	    merge_sort_aux(list,q+1,r);
	    merge(list,p,q,r);
	}
}

void merge_sort(int list[], int size)
{
    merge_sort_aux(list, 0, size - 1);
}

class heap
{
    public:
        int *nodes;
        int length;
        int heap_size;
};

void max_heapify(heap list, int index)
{

        int left,right,largest,exchange_temp;

        left = LEFT(index);
        right = RIGHT(index);

        if(left <list.heap_size && list.nodes[left] > list.nodes[index])
        {
            largest = left;
        } else
        {
            largest = index;
        }

        if(right <list.heap_size && list.nodes[right] > list.nodes[largest])
        {
            largest = right;
        }


        if(largest != index)
        {
            exchange_temp = list.nodes[index];
            list.nodes[index] = list.nodes[largest];
            list.nodes[largest] = exchange_temp;
            max_heapify(list, largest);
        }

}

void build_max_heap(heap list)
{
    list.heap_size = list.length;
    for(int i = floor(list.length/2); i>=0; i--)
    {
        max_heapify(list, i);
    }
}

void heap_sort(int list[], int size)
{
    int exchange_temp;
    heap tempheap;
    tempheap.length = size;
    tempheap.nodes = list;
    tempheap.heap_size = size;
    build_max_heap(tempheap);

    for(int i= tempheap.length - 1; i>=1; i--)
    {
        exchange_temp = tempheap.nodes[0];
        tempheap.nodes[0] = tempheap.nodes[i];
        tempheap.nodes[i] = exchange_temp;
        tempheap.heap_size = tempheap.heap_size - 1;

        max_heapify(tempheap,0);
    }
}

int main()
{
     std::chrono::high_resolution_clock::time_point t1,t2;
    srand(time(0));

    int npointsmax = 100000, nave = 100, npoints = 46;
    double  merge_timelist[npoints], heap_timelist[npoints];

    int *rlist1= new int[npointsmax];
    int *rlist2= new int[npointsmax];
    int *rlist3= new int[npointsmax];
    int *rlist4= new int[npointsmax];
    int *rlist5= new int[npointsmax];

    double nplist[npoints];
    nplist[0] = 1;
    for(int n=0;n<5;n++)
    {
        for(int j=2;j<11;j++)
        {
            nplist[9*n + j - 1] = j * pow(10,n);
        }
    }

    int icounter = 0;

    for (int npointsi : nplist)
{   

        double hptime,mgtime;
        double hp_temp_timer = 0.0;
        double mg_temp_timer = 0.0;
        cout<<npointsi<<endl;
        for(int j = 0; j< nave; j++)
        {
	    for(int ii=0;ii<npointsi;ii++)
            {
                rlist1[ii]=rlist2[ii]=rlist3[ii]=rlist4[ii]=rlist5[ii]=rand() % 1000;
            }

            t1 = std::chrono::high_resolution_clock::now();
            merge_sort(rlist1,npointsi);
            t2 = std::chrono::high_resolution_clock::now();
            mgtime = std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count();
            mg_temp_timer += mgtime ;

            t1 = std::chrono::high_resolution_clock::now();
            heap_sort(rlist2,npointsi);
            t2 = std::chrono::high_resolution_clock::now();
            hptime = std::chrono::duration_cast<std::chrono::nanoseconds>(t2-t1).count();
            hp_temp_timer += hptime ;

 		}
        merge_timelist[icounter] = mg_temp_timer/nave;
        heap_timelist[icounter] = hp_temp_timer/nave;
        icounter++;

    }

    FILE * resultsfile;
    resultsfile=fopen("results-comparison.txt","w");
    for(int j=0;j< npoints;j++) fprintf(resultsfile, "%5e \t %10.2f \t %10.2f \n", merge_timelist[j], heap_timelist[j]);
    fclose(resultsfile);
}

I get this as my outputfile:
0.000000e+000 0.00 1.00
0.000000e+000 0.00 1.00
0.000000e+000 0.00 1.00
0.000000e+000 156000.00 1.00
0.000000e+000 0.00 1.00
0.000000e+000 0.00 1.00
0.000000e+000 156000.00 1.00
0.000000e+000 0.00 1.00
0.000000e+000 0.00 1.00
1.560000e+005 0.00 1.00
0.000000e+000 156001.00 1.00
3.120000e+005 0.00 1.00
3.120000e+005 156001.00 1.00
1.560000e+005 312001.00 1.00
1.560010e+005 468000.00 1.00
1.560010e+005 312000.00 1.00
3.120010e+005 312000.00 1.00
0.000000e+000 624001.00 1.00
1.560000e+005 780002.00 1.00
3.120000e+005 1716003.00 1.00
1.092002e+006 1404003.00 1.00
1.092002e+006 2808005.00 1.00
1.092003e+006 3120005.00 1.00
1.404002e+006 3588006.00 1.00
1.716004e+006 4212007.00 1.00
2.028002e+006 4992010.00 1.00
2.496005e+006 5148009.00 1.00
2.496006e+006 6240010.00 1.00
9.360014e+006 24180045.00 1.00
8.736018e+006 22630038.00 1.00
1.076402e+007 29016052.00 1.00
1.341602e+007 36660065.00 1.00
1.638003e+007 45240082.00 1.00
1.934404e+007 53352093.00 1.00
2.199603e+007 61620114.00 1.00
2.527204e+007 70044125.00 1.00
2.823605e+007 78624140.00 1.00

[theturk1234]

Please explain what you are trying to do and what outputs you should be getting. Also, please use code tags.
Thank you!

[Indianna32]

First, Is it not in code tags? When I look at it, it is in code tags.
Second, I am trying to just get a readout of the comparison of runtimes of the two sorts, merge and heap.
Third, The output I was hoping for was just a simple chart with runtimes with a column for each different sorts.
I don't know if I have just been working on this for too long straight but I feel like it makes less sense the more I look it over.
Thank you again.