#include<stdio.

h>
#include<stdlib.h>
#include<time.h>
#define MAX 10
char final[]="final.txt";
void generanombre(char *c)
{
static int n=0;
n++;
sprintf(c, "archivo%d.txt",n);
}
int longitud(char *c)
{
int i=0;
while(c[i]!='\0')
{ //printf("%c\n",c[i]);
i++;
}
return i;
}
long
{int
long
char

encuentraAnterior(FILE *f,long pos)

i=0;
posf;
c;

do
{
fseek( f,pos, SEEK_SET);
fseek( f,-i-1, SEEK_CUR);
posf=ftell(f);
fscanf(f,"%c",&c);
i++;
}
while(c!=' '&& posf!=0);
return posf;
}
long POSICIONRANDOM(FILE *f)
{
long randon;
long posf;
srand(rand());
fseek( f,0, SEEK_END);
posf=ftell(f);
randon=rand()%posf;
//printf("randon:%ld",randon);
randon=encuentraAnterior(f,randon+1);
//printf("randon:%ld",randon);
return randon;
}
int convierteCadena(char *c)
{
int n=0;
int as;
int i;

for(i=0;i<longitud(c);i++)
{
n=n*10;
as=(int)c[i]-48;
n=as+n;
}
return n;
}
void generaNumerosAleatorios(FILE *fp)
{
srand(rand());
int i=0;
int n=rand();
while(i!=MAX)
{
n=rand()%1000000;
fprintf(fp,"%d ",n);
i++;
}
}
void generaNumerosAscendente(FILE *fp)
{
srand(rand());
int i=0;
int n=rand();
while(i!=MAX)
{
n=n+1;
fprintf(fp,"%d ",n);
i++;
}
}
void generaNumerosDescendente(FILE *fp)
{
int i=0;
int n=MAX;
while(i!=MAX)
{
n--;
fprintf(fp,"%d ",n);
i++;
}
}

void Merge(int A[],int p,int q,int r)

{int n1=q-p+1;
int n2=r-q;
long L[n1+1];
long R[n2+1];
int i,j,k;
for(i=0;i<n1;i++)
{
L[i]=A[p+i];
}
for(j=0;j<n2;j++)
{
R[j]=A[q+j+1];
//cout<<R[j]<<endl;
}
L[n1]=2000000000;
R[n2]=2000000000;
i=0;
j=0;
for(k=p;k<=r;k++)
{
if(L[i]<=R[j])
{
A[k]=L[i];
i=i+1;
}
else
{
A[k]=R[j];
j=j+1;
}
}
}
void mergesort(int A[],int p,int r )
{int q;
if(p<r)
{
q=(p+r)/2;
mergesort(A,p,q);
mergesort(A,q+1,r);
Merge(A,p,q,r);
}
}
int partition(int A[],int P,int R)
{
int x=A[R];
int i=P-1;

int temp;
int j;
for ( j=P;j<R;j++)
{
if(A[j]<=x)
{ i=i+1;
temp =A[i];
A[i]=A[j];
A[j]=temp;
}

}
temp=A[i+1];
A[i+1]=A[R];
A[R]=temp;
return i+1;
}
void quicksort(int A[],int P,int R)
{
if(P<R)
{
int q=partition(A,P,R);
quicksort(A,P,q-1);
quicksort(A,q+1,R);
}
}
long PARTITION(FILE *f,FILE *f1,FILE *f2,int r)
{
int x;
long i=0;
long j;
long pos;
long ultimo;
int a,b;
char numero[20];
char nombre[20];
pos=POSICIONRANDOM(f);
fseek(f,pos,SEEK_SET);
fscanf(f,"%s",numero);
//printf("%ld-",pos);
x=convierteCadena(numero);
//printf("%d\n",x);
fseek(f,0,SEEK_SET);
fprintf(f2,"%d ",x);
for(j=0;j<r;j++)
{
//printf("j:%ld\n",j);
//printf("i:%ld\n",i);
if(pos!=ftell(f))
{
fscanf(f,"%s",numero);
a=convierteCadena(numero);
if(a<=x)
{
i++;
//printf(" x:%d\n",x);
//printf(" a:%d\n",a);

//printf("if i:%ld\n",i);
fprintf(f1,"%d ",a);
}
else
{//printf("i:%ld\n",i);
fprintf(f2,"%d ",a);
//printf("nuemero:%s\n",numero);
}
}
else
{ fscanf(f,"%s",numero);}
}
return i;
}
void QUICKSORT( FILE *f,int r)
{
if(r>100000)
{
char sg[20];
long q2;
FILE * f1;
FILE * f2;
char nombre[20];
char nombre2[20];
int q;
generanombre(nombre);
f1=fopen(nombre,"a+t");
fclose(f1);
f1=fopen(nombre,"r+");
generanombre(nombre2);
f2=fopen(nombre2,"a+t");
fclose(f2);
f2=fopen(nombre2,"r+");
//printf("r:%d\n",r);
q=PARTITION(f,f1,f2,r);
//printf("q:%ld\n",q);
//q=encuentraAnterior(f,q);
//printf("q-1:%ld\n",q);
QUICKSORT(f1,q);
//fseek(f,q,SEEK_SET);
//fscanf(f,"%s",sg);
//q2=ftell(f);
QUICKSORT(f2,r-q);
fclose(f1);
fclose(f2);
remove(nombre);
remove(nombre2);
}
else{
int B[r];
int i;

FILE *Fn;
char numero[20];
fseek(f,0,SEEK_SET);
for(i=0;i<r;i++)
{
fscanf(f,"%s",numero);
B[i]=convierteCadena(numero);
//printf("%d\n",B[i]);
}
mergesort(B,0,r-1 );
//quicksort(B,0,r-1);
Fn=fopen(final,"a+t");
for(i=0;i<r;i++)
{
fprintf(Fn,"%d ",B[i]);
}
fclose(Fn);
}
}
int main()
{
FILE
FILE
FILE
FILE

* fa=fopen("Al.txt","a+t");
* fb=fopen("As.txt","a+t");
* fc=fopen("Ds.txt","a+t");
*fl;

double secs;
clock_t t_inicial;
clock_t t_final;
generaNumerosAleatorios(fa);
generaNumerosAscendente(fb);
generaNumerosDescendente(fc);
fclose(fa);
fclose(fb);
fclose(fc);
fl=fopen("Al.txt","r+");
t_inicial=clock();
QUICKSORT(fl,MAX);
t_final=clock();
secs=(double)(t_final-t_inicial)/(CLOCKS_PER_SEC);
fclose(fl);
printf("Para numeros Aleatorios:\n");
printf("tiempo en milisegundos=%f \n",secs*1000);
remove(final);
fl=fopen("As.txt","r+");
t_inicial=clock();
QUICKSORT(fl,MAX);
t_final=clock();
secs=(double)(t_final-t_inicial)/(CLOCKS_PER_SEC);
fclose(fl);
remove(final);
printf("Para numeros Ascendentes:\n");
printf("tiempo en milisegundos=%f \n",secs*1000);
fl=fopen("Ds.txt","r+");
t_inicial=clock();

QUICKSORT(fl,MAX);
t_final=clock();
secs=(double)(t_final-t_inicial)/(CLOCKS_PER_SEC);
fclose(fl);
printf("Para numeros Descendentes:\n");
printf("tiempo en milisegundos=%f \n",secs*1000);

//remove(final);
return 0;
}