elrincondelc.com :: Ver tema - Ayuda con este codigo en C

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<ctype.h>

struct alu
{
char nom[30];
int sem;
long nc;
};
struct limites
{
int in[2];
struct limites *sig;
};

int insertar(struct alu **reg);
void inser_direc(struct alu *reg,int n);
void met_shell(struct alu *reg,int n);
void met_burbuja(struct alu *reg,int n);
void met_conca(struct alu *reg,int n);
void concatena(struct alu *reg,int ii1,int if1,int ii2,int if2,int n);
void selec_direc(struct alu *reg,int n);
void monticulo1(struct alu *reg,int n);
void monticulo2(struct alu *reg,int n);
void muestra(struct alu *reg,int n);
void quick_sort(struct alu *vec,int n);
int div_restaura(struct alu *v,int li,int ls,struct alu piv);
struct limites *push(struct limites *pila,int l1,int l2);
int *pop(struct limites **pila);
void busqueda_bin(struct alu *reg,int n);
void met_divi(struct alu *reg,int n);
int prim(int n);

void main()
{ struct alu *raiz;
int n;//=0, opc=0, a=0, b1=0;
char res;
do{
clrscr();
/*/printf("\t **********MENU CON METODOS DE ORDENACION**********\n");
printf("\n1.ALTA DE DATOS");       printf(" 7.MONTICULO");
printf("\n2.MUESTRA DE DATOS"); printf("\t\t 8.QUICK SORT");
printf("\n3.INVIERTE DATOS"); printf("\t\t 9.METODO DE DIVISION");
printf("\n4.ORDENACION DIRECTA"); printf("\t\t 10.BUSQUEDA BINARIA");
printf("\n5.ORDENACION POR MEDIO DE SHELL"); printf(" 11.ORDENACION DIRECTA");
printf("\n6.ORDENACION POR MEDIO DE BURBUJA"); printf(" 12.SALIR");
scanf("%d",&opc);
switch(opc)
{
case '1':
if(a==0)
{
/*/
n=insertar(&raiz);
inser_direc(raiz,n);
met_shell(raiz,n);
met_burbuja(raiz,n);
quick_sort(raiz,n);
busqueda_bin(raiz,n);
met_conca(raiz,n);
selec_direc(raiz,n);
monticulo1(raiz,n);
muestra(raiz,n);
met_divi(raiz,n);
printf("\nDESEA OTRO(S/N):");
res=toupper(getch());
}while(res!='N');
}// fin del main

int insertar(struct alu **reg)
{ struct alu *aux;
int n,i;
printf("\nCUANTOS ELEMENTOS DESEA INSERTAR:");
scanf("%d",&n);
aux=(struct alu *)malloc(n*sizeof(struct alu));
if(aux!=NULL)
{ for(i=0;i<n;i++)
{
printf("\nNUMERO DE CONTROL :");
scanf("%ld",&aux[i].nc);
printf("\nNOMBRE :");
fflush(stdin);
gets(aux[i].nom);
printf("\nSEMESTRE :");
scanf("%d",&aux[i].sem);

}
*reg=aux;
}// fin del if
else
printf("\nNO HAY MEMORIA SUFICIENTE");
return n;
}// fin de la funcion

void muestra(struct alu *reg,int n)
{ int i=0;
clrscr();
printf("\nLOS DATOS SON: \n");
for(i=0;i<n;i++)
{
printf("\nNUMERO DE CONTROL: %ld ",reg[i].nc);
printf("\nNOMBRE: %s ",reg[i].nom);
printf("\nSEMESTRE: %d ",reg[i].sem);

getch();
}
}//fin de la funcion

void inser_direc(struct alu *reg,int n)
{ int i,j;
struct alu aux;
for(i=1;i<=n-1;i++)
{ j=i-1;
while( (j>=0) && (reg[j].nc > reg[j+1].nc) )
{ aux=reg[j];
reg[j]=reg[j+1];
reg[j+1]=aux;
j--;
}
}// del for
}// fin de la funcion

void met_shell(struct alu *reg,int n)
{ int paso,i,j;
struct alu aux;
paso=n/2;
n=n-1;
while(paso>0)
{
for(i=paso;i<=n;i++)
{ j=i-paso;
while( (j>=0) && ( (reg[j].nc) > (reg[j+paso].nc) ) )
{ aux=reg[j];
reg[j]=reg[j+paso];
reg[j+paso]=aux;
j=j-paso;
}//del while
}// del for
paso=paso/2;
}// del while externo
}// fin de la funcion

void met_burbuja(struct alu *reg,int n)
{ int i,j;
struct alu aux;
for(i=1;i<=n-1;i++)
{ for(j=1;j<=n-i;j++)
{ if( (reg[j-1].nc) > (reg[j].nc) )
{
   aux=reg[j];
   reg[j]=reg[j-1];
   reg[j-1]=aux;
}
}//del for interno
}//del for externo
}//fin de la funcion

void met_conca(struct alu *reg,int n)
{
int ie=0,tam,ii;
tam=1;
while(tam<n)
{
ii=0;
do{
concatena(reg,tam*(2*ii),(tam*((2*ii)+1))-1,tam*((2*ii)+1),(tam*((2*ii)+2))-1,n);
ii++;
}while( (tam*((2*ii)+1) < n) && (tam*((2*ii)+1) <=(tam*((2*ii)+2))-1 ) );
ie++;
tam=tam*2;
}// fin del while
}// fin de la funcion

void concatena(struct alu *reg,int ii1,int if1,int ii2,int if2,int n)
{ int k=0,i=ii1,j=ii2;
struct alu *aux;
aux=(struct alu *)malloc(n*sizeof(struct alu));
if(aux!=NULL)
{
while(i<=if1)
{ while( ( (j<n) && (j<=if2) )&& ((reg[j].nc) < (reg[i].nc) ) )
{ aux[k]=reg[j];
   j++;
   k++;
}// del if ext
aux[k]=reg[i];
k++;
i++;
}// del while externo
j=0;
i=ii1;
while(j<k)
{ reg[i]=aux[j];
j++;
i++;
}// del while
free(aux);
}// del if aux !=NULL
else
{
printf("\nNO HAY MEMORIA");
}
}// fin de la funcion

void selec_direc(struct alu *reg,int n)
{ int j,i=0;
struct alu aux;
while(i<n)
{ for(j=i+1;j<n;j++)
{ if(reg[i].nc > reg[j].nc)
{ aux=reg[i];
reg[i]=reg[j];
reg[j]=aux;
}//fin del if
}// fin del for
i++;
}// fin del while
}// fin de la funcion

void monticulo1(struct alu *reg,int n)
{ int i=n-1;
struct alu aux;
monticulo2(reg,n);
while(i>=0)
{ aux=reg[0];
reg[0]=reg[i];
reg[i]=aux;
monticulo2(reg,i);
i--;
}
}// fin de la funcion

void monticulo2(struct alu *reg,int n)
{ struct alu aux;
int j,k=1,sigue;
while(k<n)
{ j=k; sigue=1;
while( (j>0) && (sigue==1) )
{ if( (j%2 != 0) && (reg[j].nc > reg[j/2].nc) )
{ aux=reg[j];
reg[j]=reg[j/2];
reg[j/2]=aux;
j=j/2;
}// fin del if
else
{ if( (j%2 ==0) && (reg[j].nc > reg[j/2 -1].nc ) )
{ aux=reg[j];
   reg[j]=reg[j/2 -1];
   reg[j/2 -1]=aux;
   j=j/2 -1;
}
else
sigue=0;
}// fin del else externo
}// fin del while j>0 ...
k++;
}// fin del while
}// fin de la funcion

void quick_sort(struct alu *vec,int n)
{ int ip,*lim,li=0,ls=n-1,izq;
struct limites *pila;
struct alu pivote;
pila=NULL;
do{
izq=1;
while(izq==1 )
{ pivote=vec[li];
ip=div_restaura(vec,li,ls,pivote);
if( ip+1 >=li && ip+1 <= ls )
   pila=push(pila,ip+1,ls);
if( (ip-1 >=li) && ( ip-1 <= ls) )
{ izq=1;
   ls=ip-1;
}// del if
else
izq=0;
}// del while
lim=pop(&pila);
li=*(lim+0);
ls=*(lim+1);
}while( li!=-1 && ls!=-1 );
}// fin de la funcion

int div_restaura(struct alu *v,int li,int ls,struct alu piv)
{ int k=0,j=0,iz=0,de=0,i,l;
struct alu *izq,*der;
if(li < ls)
{
der=(struct alu *)malloc(ls*sizeof(struct alu));
izq=(struct alu *)malloc(ls*sizeof(struct alu));
if( (izq!=NULL) && (der!=NULL) )
{
for(i=li;i<ls;i++)
{if( piv.nc > v[i+1].nc )
{ izq[j]=v[i+1];
   j++;
   iz=1;
}
else
{ der[k]=v[i+1];
   k++;
   de=1;
}
}// del for

if( (iz==1) && (de==1) )
{ v[li+j]=piv;
k=0; l=0;
for(i=li;i<li+j;i++)
   { v[i]=izq[l];
   l++;
   }
for(i=li+(j+1);i<=ls;i++)
   { v[i]=der[k];
   k++;
   }
}
else
{ if( (iz==1) && (de==0) )
{ v[li+j]=piv; l=0;
   for(i=li;i<(li+j);i++)
   { v[i]=izq[l];
   l++;
   }
}
else
if( (iz==0) && (de==1) )
{ v[li]=piv;
   k=0;
   for(i=li+1;i<=ls;i++)
   { v[i]=der[k];
   k++;
   }
   free(izq);
   free(der);
   return li;
}
}
free(izq);
free(der);
}// del if izq!=NULL
else
printf("\nNO HAY MEMORIA");
}// del if li != ls
else
return li;
return (li+j) ;
}// fin de la funcion

struct limites *push(struct limites *pila,int l1,int l2)
{ struct limites *aux;
aux=(struct limites *)malloc(sizeof(struct limites));
if(aux!=NULL)
{ (*aux).in[0]=l1;
(*aux).in[1]=l2;
(*aux).sig=pila;
pila=aux;
}// del if
return pila;
}// fin de la funcion

int *pop(struct limites **pila)
{ struct limites *aux;
int limit[2];
if( (*pila)!=NULL )
{ aux=(*pila);
(*pila)=(*(*pila)).sig;
limit[0]=(*aux).in[0];
limit[1]=(*aux).in[1];
free(aux);
}
else
{ limit[0]=-1;
limit[1]=-1;
}
return limit;
}// fin de la funcion

void busqueda_bin(struct alu *reg,int n)
{ int li=0,ls=n-1,medio;
long clave;
printf("\nPROPORCIONE EL NUMERO DE CONTROL A BUSCAR: ");
scanf("%ld",&clave);
do{
medio=(li+ls)/2;
if (clave > reg[medio].nc )
li=medio+1;
else
ls=medio-1;
}while( (reg[medio].nc!=clave)&& (li<=ls) );
if(reg[medio].nc==clave)
{ printf("\nNUMERO DE CONTROL: %ld ",reg[medio].nc);
printf("\nNOMBRE: %s ",reg[medio].nom);
printf("\nSEMESTRE: %d ",reg[medio].sem);

}
else
printf("\nEL ELEMENTO NO EXISTE");
getch();
}//fin de la funcion

void met_divi(struct alu *reg,int n)
{ struct alu *aux;
int m,i,div;
long k;
m=n;
do{
m=prim(m);
}while(n/m > 0.8);
aux=(struct alu *)malloc(m*sizeof(struct alu));
if(aux!=NULL)
{ for(i=0;i<m;i++)
aux[i].nc=0; i=0;
while(i<n)
{ k=reg[i].nc;
div= k % m;
if(aux[div].nc==0)
aux[div]=reg[i];
else
printf("\nCOLISION EN LA POSICION %d ",div);
i++;
}

}// fin del if
else
printf("\nNO HAY MEMORIA SUFICIENTE");
}// fin de la funcion

int prim(int m)
{ int i,modulo,ban=0;
do
{ i=2;
m++;
do{
modulo=m%i;
i++;
}while( (i<m)&& (modulo!=0) );
if(modulo==0)
ban=0;
else
ban=1;
}while( ban!=1 );
return m;
}// fin de la funcion