compile visual studio c++ online

Language: Layout:

#include <algorithm>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <time.h>
using namespace std;

struct Node {
    int data;
    int *edge ; //stores the node number of each child node
};
// Yes they are global variables
vector<int> stack;
vector<Node> tree;
vector<int*>callstack;

void fillwithrandom(int *n,int *m,int count)
{
    int a;
    //int *V={3,0,0};
    Node T;
    T.data=rand()%2;T.edge=&(*(int*)malloc(3*sizeof(int))=3);
    tree.push_back(T);
    stack.push_back(T.data);
	//printf ("%d ",tree[0].edge[0]);
    if ((a=rand()%count)!=0)
	   fillwithrandom(&(*n=(T.edge[1]=++(*n))),&(++(*m)),a);
    else return stack.push_back((T.edge[0]=0)-++(*m));

//stack.push_back(-++(*m));

while ((a=rand()%count)==0);
    fillwithrandom(&(*n=(T.edge[2]=++(*n))),&(++(*m)),a);
    
	stack.push_back(-++(*m));
}

void iterativeapproach( int* m){

int level=0,lasti,previouslevel=0;
	//*m=1;
    /*for (int i=1;stack[i]!=-i-1;*n=previous,i+=!!((previous=(stack[i]<0)?stack[i-1]:stack[i])+1)){
		//a=stack[i];
		level=(*n>=(stack[i]<0)+(previous=*n-level*(stack[i]==!previous)+(stack[i]>=0)))?1:level+2*(stack[i]>=0)-1;
		}//level=((count=5)==(count))?1:3;}
	*/

for (int i=0;stack[i]!=-i-1;i++){
		
	if(i>=2)
	if (stack[i]>=0)
		/*if (stack[(*lasti)-1]<0)
			if ((stack[*i-2]&1)==(stack[*i]&1))
			  {(*m)++;(*level)++;stack[*i]+=2;}
			else{*m=*m-*level+1;previouslevel=*level;*level=1;}
		else*/
			if ((stack[lasti]&1)==(stack[i]&1))
			  {(*m)++;(level)++;stack[lasti=i]+=2;}
			else
			{*m=*m-level+1;previouslevel=level;level=1;lasti=i;}
	else 
	(level)-=!!level;
	else if(i==1)
	{/*(*m)++;*/(*m)+=(stack[i-1]&1==stack[i]&1);previouslevel=level;level=*m;stack[i]+=2;lasti=i;}
	else if(i==0)
	{*m=1;previouslevel=level;level=1;stack[i]+=2;lasti=i;};
	
			
	}

for (int i=1;stack[i]!=-i-1;i++){
		
	if (stack[i]>=0)
		if (stack[i-1]<0)
			if (stack[i-2]==stack[i])
			  {(*n)++;level++;}
			else{*n=*n-level+1;level=1;}
		else
			if (stack[i-1]==stack[i])
			  {(*n)++;level++;}
			else{*n=*n-level+1;level=1;}
	else level -=!!level;
			  
	///if (stack[i-1]<0)
	///printf("%d ",*n);

//level=(*n>=(stack[i]<0)+(previous=*n-level*(stack[i]==!previous)+(stack[i]>=0)))?1:level+2*(stack[i]>=0)-1;f
		}

//return count+1;
}

void iterativetree( int* m){

int level=0,lasti,previouslevel=0,stackk;
	callstack.clear();
	//*m=1;
    /*for (int i=1;stack[i]!=-i-1;*n=previous,i+=!!((previous=(stack[i]<0)?stack[i-1]:stack[i])+1)){
		//a=stack[i];
		level=(*n>=(stack[i]<0)+(previous=*n-level*(stack[i]==!previous)+(stack[i]>=0)))?1:level+2*(stack[i]>=0)-1;
		}//level=((count=5)==(count))?1:3;}
	*/

callstack.push_back(&(*(int*)malloc(2*sizeof(int))=0));stackk=(lasti=tree[callstack[0][1]=0].data);
	for (int j=0;j>=0;){
		
		
	////if(i>=2)
	if (stackk>=0)
		/*if (stack[(*lasti)-1]<0)
			if ((stack[*i-2]&1)==(stack[*i]&1))
			  {(*m)++;(*level)++;stack[*i]+=2;}
			else{*m=*m-*level+1;previouslevel=*level;*level=1;}
		else*/
			if ((lasti&1)==(stackk&1))
			  {(*m)++;(level)++;lasti=stackk;}
			else
			{*m=*m-level+1;previouslevel=level;level=1;lasti=stackk;}
	else 
	(level)-=!!level;
	////else if(i==1){/*(*m)++;*/(*m)+=(lasti&1==stack&1);previouslevel=level;level=*m;lasti=stack;}
	////else if(i==0){*m=1;previouslevel=level;level=1;lasti=stack;};
	
	
	if (++callstack[j][1]==tree[callstack[j][0]].edge[0]|tree[callstack[j][0]].edge[0]==0)
		{callstack.pop_back();j--;stackk=-1;}
		else 
		{callstack.push_back(&(*(int*)malloc(2*sizeof(int))=tree[callstack[j][0]].edge[callstack[j][1]]));//{tree[callstack[j][0]].edge[callstack[j][1]],0});
		j++;callstack[j][1]=0;stackk=tree[callstack[j][0]].data;};
		
	}

//level=(*n>=(stack[i]<0)+(previous=*n-level*(stack[i]==!previous)+(stack[i]>=0)))?1:level+2*(stack[i]>=0)-1;f
		}

//return count+1;
}

//n is the number of the node at which the tree is rooted
//initally we call isUnivalued(0)

bool isUnivalued(unsigned n,int *count) {
    if(tree[n].edge[0] == 0){
        printf("",(*count)++);
        return true; //leaves are univalued
    }
    bool allUnivalued = true;
    for(int i=1;i<tree[n].edge[0] ;i++)
        if(!isUnivalued(tree[n].edge[i],count))
            allUnivalued = false;
    if(!allUnivalued)
        return false;
    for(int i=1;i<tree[n].edge[0] ;i++)
        if(tree[tree[n].edge[i]].data != tree[n].data)
            return false;
    (*count)++;
    return true;
}

int main(){
	double count=0 ;
    int a,b,c,d;
	clock_t time1,time2,time3,time4;
do{ tree.clear();stack.clear();
	
	tree.reserve(c=rand());
    stack.reserve(2*c);
	callstack.reserve(c);

// filling with random values    
	fillwithrandom(&(a=0),&(b=0),c);
	stack[b]--;

// match cases
    //time(&time1);
	time1=clock();
    isUnivalued( 0,  &(b=0));//printf("\n ");printf("\n ");
	time2=clock();//time(&time2);
    iterativeapproach(&(a=0));//printf("\n ");printf("\n ");
	time3=clock();//time(&time3);
    ////iterativetree(&(a=0));
	////time4=clock();//time(&time3);
    
	
	if(b!=a)
	   printf("something will never occur",system("pause"));
	else if(stack.size()>90000)
	{printf("your approach returns %d after %d time-units",a,(long)(time2-time1));printf("\n ");
	 printf("  My approach returns %d after %d time-units",b,(long)(time3-time2));printf("\n \n ");
     return 1; }
	}while(1);
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1.4 sec, absolute running time: 0.68 sec, absolute service time: 2.1 sec