elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Ayuda con metodo de ordenacion		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Ayuda con metodo de ordenacion  (Leído 4,377 veces)
Rilax

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Ayuda con metodo de ordenacion
« en: 18 Junio 2010, 02:29 am »
Hola a todos, bueno quieresa ver si me echan la mano para hacer que corra bien un programita que ya me saco CANAS tras CANAS no ya sta la mayoria lo uniko k me falta es el metodo de ordenacion que no me corre en la Universidad el Ingeniero nos dijo que por el metodo de ordenacion que queramos y yo lo ise por el de la burbuja pero no me sale no se si alguien de ustedes me podria ayudar si lo hacen MIL gracias o si ven en donde esta mi error DIGANME por que yo ya no doy mas xD saluditos y espero respuesta aqui les dejo el codigo (lo corri en Turbo C)

Código:
#include <stdio.h>          
#include <conio.h>          
#include <string.h>         
#include <graphics.h>       
#include <stdlib.h>
#include <process.h>
#define TAM 20
#include <ctype.h>
#include "graphics.h"
char nombre[20];
/****************************estructura principal************************/
	  struct ferreteria
		    {
		     char articulo[TAM]; /*c articulo*/
		     char clave[10];
		     char precio[10]; /* precio*/
		     char marca[10];    //otro
		    }datos;
/***********************************funciones*******************************/
		       void ordenar(struct ferreteria);
		   //    void crear();
		       void insertar(struct ferreteria );
		       void visualizar(struct ferreteria );
		       void buscar(struct ferreteria );
		       void modificar(struct ferreteria );
		       void borrar(struct ferreteria );
		       void acerca();
		       void articulo(struct ferreteria );
		       void precio(struct ferreteria );
		       void clave(struct ferreteria );
		       void marca(struct ferreteria );
		       int valido(char *, struct ferreteria );
/***************************iniciamos el menu principal******************/
       void main()
    {
   /*********************************iniciamos los graficos**************/

	  int gdriver = DETECT, gmode, errorcode;
	  int midx, midy, i;

	   initgraph(&gdriver, &gmode, "");
	   errorcode = graphresult();
	   if (errorcode != grOk)
	      {
	       printf("Error de Graficos: %s\n", grapherrormsg(errorcode));
	       printf("Presiona una tecla para continuar:");
	       getch();
	       exit(1);
	      }

	       char opcion;
	       int salir=0;
     /**************************terminamos graficas********************/
       do
	{

	  clrscr();

	  setfillstyle(SOLID_FILL,BLUE);
	  bar(120,60,550,240);                /*primer bar 3d*/
			/*sobre el primer*/

	  printf("\n\n\n");
	  printf("\n\n\t\tCONTROL DE FERRETERIA\n\n");
	 // printf("\n\n\t0. CREAR\n"        );
	  printf("\t\t\t1. ALTAS\n"        );
	  printf("\t\t\t2. MOSTRAR TODO\n" );
	  printf("\t\t\t3. CONSULTAR\n"    );
	  printf("\t\t\t4. MODIFICAR \n"   );
	  printf("\t\t\t5. BAJAS\n"        );
	  printf("\t\t\t6. INTEGRANTES\n");
	  printf("\t\t\t7. ORDENAR\n\n"    );
	   moveto(250,300);outtext("PULSA ESC PARA SALIR");   /*pocision de esc*/
	  setfillstyle(SOLID_FILL,7);       /*color de fondo 2*/
	  bar(0,0,120,240);
	  setbkcolor(BLUE);                    /*color de fondo3*/
	  rectangle(120,60,550,240);
	  rectangle(116,56,554,244);        /*rectangulo sobre otro*/
	  rectangle(240,295,420,310);
	  rectangle(236,291,424,314);

	  opcion=getch();
	  clrscr();
	  switch(opcion)
		   {
		    case '1':  insertar(datos);
		    break;

		    case '2':  visualizar(datos);
		    break;

		    case '3':  buscar(datos);
		    break;

		    case '4':  modificar(datos);
		    break;

		    case '5':  borrar(datos);
		    break;

		    case '6':  acerca();
		    break;

		   case '7':
			       ordenar(datos);

		    case 27:  salir=1;
		    break;
		   }
	}
    while(!salir);
}

/**************************insertar los datos en la estructura**************/
    void insertar(struct ferreteria datos)
   {
    clrscr();                                            /*limpiamos pantalla*/
    FILE *f;
    FILE *control;
    int result;
    char clave[10];
    printf("\t\t LOS DIRECTORIOS SON \n C: \n D: \n K: \n\n");

    printf("\n INTRODUCE EL NOMBRE DE EL ARCHIVO\n");

     gets(nombre);
    f=fopen(nombre,"at+");
    //control=fopen("contro.doc","w+");
    clrscr();
    if(!f)
	{
	printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
	getch();
	exit(1);
	}


	/*************************************************/
	printf("PARA TERMINAR LA INTRODUCCION DE REGISTROS, EN CLAVE ESCRIBE '*'\n");
//	fprintf(control,"clave");      /* l clave l producto l precio l marca l */
  //	fprintf(control,"\t\t producto");   /* l_______l__________l________l_______l */
    //	fprintf(control,"\t\t precio");
      //	fprintf(control,"\t\t marca\n");             /*imprimimos con formato*/
	printf("CLAVE:");
	gets(clave);   fflush(stdin);
	fclose(f);
	result=valido(clave, datos);
	f=fopen(nombre,"at+");
	while(!result)
	    {
	    printf("LA CLAVE YA EXISTE\n");
	    printf("CLAVE: ");
	    gets(clave);   fflush(stdin);
	    fclose(f);
	    result=valido(clave, datos);
	    f=fopen(nombre,"at+");
	    }	strcpy(datos.clave,clave);
	 while(strcmp(datos.clave,"*"))
	{




	printf("ARTICULO: ");
	gets(datos.articulo);   fflush(stdin);
	printf("PRECIO ");
	gets(datos.precio);   fflush(stdin);

	printf("MARCA: ");
	gets(datos.marca);   fflush(stdin);

	fwrite(&datos,sizeof(datos),1,f);
	fprintf(control,"%s",datos.clave);
	fprintf(control,"%s\t\t",datos.articulo);
	fprintf(control,"%s\t\t",datos.precio);
	fprintf(control,"%s\t\t\n",datos.marca);

       //	system("cls");

	clrscr();
	printf("PARA TERMINAR LA INTRODUCCION DE REGISTROS, EN CLAVE ESCRIBE '*'\n");

	printf("CLAVE:");
	gets(clave);   fflush(stdin);
	fclose(f);
	result=valido(clave, datos);
	f=fopen(nombre,"at+");
	while(!result)
	    {
	    printf("LA CLAVE YA EXISTE\n");
	    printf("CLAVE: ");
	    gets(clave);   fflush(stdin);
	    fclose(f);
	    result=valido(clave, datos);
	    f=fopen(nombre,"at+");
	    }	strcpy(datos.clave,clave);

	}
    fclose(f);
    fclose(control);
}
/**********************************ver los datos introducidos***************/
void visualizar(struct ferreteria datos)
{
    clrscr();
    FILE *f;

    f=fopen(nombre,"rt+");
    if(!f)
	{
	printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
	getch();
	exit(1);
	}
    while(fread(&datos,sizeof(datos),1,f))
	{
	printf("ARTICULO: %s\n", datos.articulo);
	printf("CLAVE: %s\n", datos.clave);
	printf("PRECIO: %s\n", datos.precio);
	printf("MARCA: %s\n", datos.marca);
	getch();
	clrscr();
	}
    fclose(f);
}

void buscar(struct ferreteria datos)
{
    clrscr();
    char opcion;
    int salir=0;
    do
	{              /*metemos el do while para seguir buscando*/
	  clrscr();
		 setfillstyle(SOLID_FILL,5);
		 bar(0,0,640,120);
		 printf("\t\t\t\tBUSCAR\n");
		 printf("\t\t\t\t------\n");
		 printf("\t\t\t1. ARTICULO\n");
		 printf("\t\t\t2. CLAVE\n");
		 printf("\t\t\t3. PRECIO\n");
		 printf("\t\t\t4. MARCA\n\n");
		 moveto(250,300);outtext("PULSA ESC PARA SALIR");
		 rectangle(240,295,420,310); //rectan de salir
		 rectangle(236,291,424,314); //rectan1 de salir
		 rectangle(0,0,638,120);


	opcion=getch();
	switch(opcion)
	    {
	    case '1':  articulo(datos);
	    break;
	    case '2':  clave(datos);
	    break;
	    case '3':  precio(datos);
	    break;
	    case '4':  marca(datos);
	    break;
	    case 27:  salir=1;
	    break;
	    }
	}
    while(!salir);
}
/**************************FUNCION PARA MODIFICAR FERRETERIA...************/
void modificar(struct ferreteria datos)
{
    clrscr();
    FILE *f;
    FILE *control;
    char opcion, articulo[TAM],clave[10];
    int salir=0,salirf=0, encontrado=0;
    do
	{
	system("cls");
	f=fopen(nombre,"rt+");

	printf("INGRESA LA CLAVE A MODIFICAR: ");
	gets(clave);   fflush(stdin);
	fread(&datos,sizeof(datos),1,f);
	while(!feof(f)&&!salir)
	    {
	    if(!strcmp(datos.clave,clave))
		{
		printf("ARTICUL0 (antiguo): %s\n", datos.articulo);
		printf("ARTICULO (nuevo): ");
		gets(datos.articulo);   fflush(stdin);
		printf("CLAVE (antiguo): %s\n", datos.clave);
		printf("CLAVE (nuevo): ");
		gets(datos.clave);   fflush(stdin);
		printf("PRECIO (antiguo): %s\n", datos.precio);
		printf("PRECIO(nuevo): ");
		gets(datos.precio);   fflush(stdin);
		printf("MARCA (antiguo): %s\n", datos.marca);
		printf("MARCA (nuevo): ");
		gets(datos.marca);   fflush(stdin);
		fseek(f,-(long)sizeof(datos),SEEK_CUR);
		fwrite(&datos,sizeof(datos),1,f);

		fwrite(&datos,sizeof(datos),1,control);
		encontrado=1;
		salir=1;
		}
	    else
		 fread(&datos,sizeof(datos),1,f);

	    }
	if(!encontrado)
	    printf("NO SE HA ENCONTRADO EL REGISTRO QUE BUSCA\n");
	fclose(f);

	printf("¨DESEA MODIFICAR OTRO REGISTRO? (S/N)?\n");
	opcion=toupper(getch());
	if(opcion=='N')
	    salirf=1;
	else
	    salir=0;
	}
    while(!salirf);
}

void borrar(struct ferreteria datos)
{
    clrscr();
    FILE *f, *f_temp;
    char opcion, clave[10];
    int salir=0;
    do
	{
	system("cls");
	f=fopen(nombre,"rt+");
	f_temp=fopen("ferreteria_temp","wt+");
	if(!f)
	    {
	    printf("ERROR EN LA APERTURA DEL ARCHIVO\n");
	    getch();
	    exit(1);
	    }
	if(!f_temp)
	    {
	    printf("ERROR EN LA APERTURA DEL ARCHIVO TEMPORAL\n");
	    getch();
	    exit(1);
	    }
	printf("INGRESA LA CLAVE A BORRAR: ");
	gets(clave);   fflush(stdin);
	fread(&datos,sizeof(datos),1,f);
	while(!feof(f))
	    {
	    if(strcmp(clave,datos.clave))
		fwrite(&datos,sizeof(datos),1,f_temp);
	    fread(&datos,sizeof(datos),1,f);
	    }
	fclose(f);
	fclose(f_temp);
	remove(nombre);
	rename("ferreteria_temp",nombre);
     //	remove("ferreteria_temp" );
	printf("¨DESEA BORRAR OTRO REGISTRO? (S/N)\n");
	opcion=toupper(getch());
	if(opcion=='N')
	    salir=1;
	}
    while(!salir);
}

void acerca()
{   clrscr();
		 setfillstyle(SOLID_FILL,5);
		 bar(26,76,604,184);
		 rectangle(26,76,604,184);
		 gotoxy(5,5);   printf("INTEGRANTES\n\n");
		 printf("\t\t\t\tARTURO GONZALEZ\n");
		 printf("\t\t\t\tCARLOS ABRAHAM\n ");
		 printf("\t\t\t\tMAYRA SANTANA\n");
		 printf("\t\t\t\tCLAUDIA ACU¥A\n");
		 rectangle(30,80,600,180);
		 moveto(250,300);outtext("PULSA ESC PARA SALIR");
		 rectangle(240,295,420,310);
		 rectangle(236,291,424,314);

					  //para que no tape los
						  //printfllllllllllllllll


		 getch();
}
/***********************************funcion de el articulo a escribir*******/
   void articulo(struct ferreteria datos)
     {
	 clrscr();
	 FILE *f;
	 char articulo[TAM], opcion;
	 int salir=0, encontrado=0;
      do
	{
	system("cls");
	f=fopen(nombre,"rt+");
	if(!f)
	    {
	    printf("ERROR EN LA APERTURA DEL ARCHIVO\n");
	    getch();
	    exit(1);
	    }
	printf("INGRESA EL ARTICULO A BUSCAR: ");
	gets(articulo);   fflush(stdin);
	while(fread(&datos,sizeof(datos),1,f))
	    {
	    if(!strcmp(datos.articulo,articulo))
		{
		printf("ARTICULO %s\n", datos.articulo);
		printf("CLAVE: %s\n", datos.clave);
		printf("PRECIO: %s\n", datos.precio);
		printf("MARCA: %s\n\n", datos.marca);
		encontrado=1;
		}
	    }
	if(!encontrado)
	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
	    printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)\n");
	    opcion=toupper(getch());
	    if(opcion=='N')
	    salir=1;
	else
	    encontrado=0;
	fclose(f);
	}
    while(!salir);
}
 /***************************funcion de el precio *************************/
      void precio(struct ferreteria datos)
      {
	   clrscr();
	   FILE *f;
	   char opcion, precio[10];
	   int salir=0, encontrado=0;
	do
	  {
	   system("cls");
	   f=fopen(nombre,"rt+");
	   if(!f)
	    {
	     printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
	     getch();
	     exit(1);
	    }
	  printf("INTRODUCE EL PRECIO A BUSCAR: ");
	  gets(precio);   fflush(stdin);
	  while(fread(&datos,sizeof(datos),1,f))
	    {
	     if(!strcmp(precio,datos.precio))
		{
		 printf("ARTICULO: %s\n", datos.articulo);
		 printf("CLAVE: %s\n", datos.clave);
		 printf("PRECIO: %s\n", datos.precio);
		 printf("MARCA: %s\n\n", datos.marca);
		 encontrado=1;
		}
	    }
	if(!encontrado)
	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
	printf("¨DESEA BUSCAR OTRO REGISTRO (S/N)\n");
	opcion=toupper(getch());
	if(opcion=='N')
	    salir=1;
	else
	    encontrado=0;
	fclose(f);
	}
    while(!salir);
}
/**************************funcion para el campo clave y todo su desarrollo**/
void clave(struct ferreteria datos)
{
    clrscr();
    FILE *f;
    char opcion, clave[10];
    int salir=0, encontrado=0;
    do
	{
	system("cls");
	f=fopen(nombre,"rt+");
	if(!f)
	    {
	    printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
	    getch();
	    exit(1);
	    }
	printf("INGRESA LA CLAVE A BUSCAR: ");
	gets(clave);   fflush(stdin);
	while(fread(&datos,sizeof(datos),1,f))
	    {
	    if(!strcmp(clave,datos.clave))
		{
		printf("ARTICULO: %s\n", datos.articulo);
		printf("CLAVE: %s\n", datos.clave);
		printf("PRECIO: %s\n", datos.precio);
		printf("MARCA: %s\n\n", datos.marca);
		encontrado=1;
		}
	    }
	if(!encontrado)
	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
	printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)\n");
	opcion=toupper(getch());
	if(opcion=='N')
	    salir=1;
	else
	    encontrado=0;
	fclose(f);
	}
    while(!salir);
}
/**********************************funcion  para el campo marca*************/
       void marca(struct ferreteria datos)
      {
       FILE *f;
       char opcion, marca[10];
       int salir=0, encontrado=0;
       do
	 {
	  system("cls");
	  f=fopen(nombre,"rt+");
	  if(!f)
	      {
	       printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
	       getch();
	       exit(1);
	      }
	       printf("INGRESA LA MARCA A BUSCAR: ");
	       gets(marca);   fflush(stdin);
	       while(fread(&datos,sizeof(datos),1,f))
		{
		 if(!strcmp(marca,datos.marca))
		      {
			printf("ARTICULO: %s\n", datos.articulo);
			printf("CLAVE: %s\n", datos.clave);
			printf("PRECIO: %s\n", datos.precio);
			printf("MARCA: %s\n\n", datos.marca);
			encontrado=1;
		      }
		}
	if(!encontrado)
	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
	printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)?\n");
	opcion=toupper(getch());
	if(opcion=='N')
	    salir=1;
	else
	    encontrado=0;
	fclose(f);
	}
    while(!salir);
}

/***********esta funcion es para ver si el archivo esta bien hecho o no****/
int valido(char clave[], struct ferreteria datos)
{
    FILE *f;
    int esvalido=1;
    f=fopen(nombre,"rt+");
    fread(&datos,sizeof(datos),1,f);
    while(!feof(f)&&esvalido)
	{
	if(!strcmp(clave,datos.clave))
	    esvalido=0;
	else
	    fread(&datos,sizeof(datos),1,f);
	}
    fclose(f);
    return esvalido;
}


/***************************ordenar las claves por m. de burbuja*************************************/


	void ordenar(struct ferreteria datos)
       {

	FILE *f;
	int p, aux;
	int nclaves=1;
	int arreglo1[50];
	int arreglo2[50];
	int valor[200];
	int x,i=1,j=2, temp;
	int a;


	int valor1[23];





	if((f=fopen(nombre,"rt+"))==NULL)
	 {
	  printf("\nEL FICHERO NO EXISTE.");
	  getch();
	  exit(0);
	  }

	  while(!feof(f)&&!exit)
	 {
	  fread(&datos, sizeof(datos),1,f);


	  valor1[nclaves]=atoi(datos.clave);
	  nclaves=nclaves+1;
	 }

	  if(valor1[i]>valor1[j])
	    {
	     valor[j]=aux;
	     valor[i]=valor[j];
	     valor[j]=valor[i];
	     j++;
	     i++;
	    }
	  else
	   {
	    i++;
	    j++;
	   }

	   for(i=1;i<=nclaves;i++)
	    {
	     printf("%d",valor[i]);
	    }

	 fclose(f);
	 getch();


   }

/***************************************************************************************/

  /* void crear()
   {
    FILE *f;
    printf("\t\t Los directorios son \n C: \n D: \n K: \n\n");
    printf("\n INTRODUCE EL NOMBRE DE EL ARCHIVO\n");

    gets(nombre);
    f=fopen(nombre,"w+");
    if(f!=NULL)
       {
	printf("\n Fichero creado.....\n");
       }
	else
	 {
	  printf("\n Error en el archivo\n");
	 }
    getch();
   }
    */

si lo gustan descargar lo subi a varios del k gusten ;)

http://www.sendspace.com/file/srwxqo

http://rapidshare.com/files/399850495/ProyectoFinal.CPP.html

http://www.2shared.com/file/exh0kCVc/ProyectoFinal.html

http://www.filefactory.com/file/b21675f/n/ProyectoFinal.CPP

http://ifile.it/3t9evgj/ProyectoFinal.CPP

CUALQUIER AYUDA sirve si no le tiran mucho a la de burbuja me dijero k puede ser otro metodo es k soy principiante en esto GRACIAS POR RESPONDER!! ;););)
En línea
AckeR

Desconectado Desconectado

Mensajes: 109


Tu única Limitación Es tú Imaginación (:


Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #1 en: 18 Junio 2010, 03:40 am »
Hola!

Podrías ver bien como es la síntaxis para usar el método burbuja!

creo que deberías recorrer los vectores con algún bucle(2 for)
para así te pueda ordenar dependiendo como lo quieras!

Código:
algoritmo burbuja( A : array de n elementos indizados de 1 a n)
  para i desde 1 hasta n-1 hacer: //las n-1 pasadas
       para j desde 1 hasta n-i hacer: //el recorrido
         si A[j] > A[j+1] entonces //Si no están en orden
           intercambiar A[j] y  A[j+1] //Se intercambian
       fin para
  fin para
fin algoritmo


No he visto detalladamente tu code pero creo que ahí puede estar el error de que no ordena como corresponde.!
Y otra cosa utiliza GeSHi para poder visualizar mejor el code !

suerte!!
En línea

...DaR LaS GraCiaS No CuestA NadA...
Rilax

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #2 en: 18 Junio 2010, 04:29 am »
no no no ordena anda le doy a la opcion de ordenas y me sale un numero asi: -213666 y ya es todo lo k me sale...

lo k tengo en ordenacion es:
Código
  1. 	void ordenar(struct ferreteria datos)
  2.        {
  3.  
  4. 	FILE *f;
  5. 	int p, aux;
  6. 	int nclaves=1;
  7. 	int arreglo1[50];
  8. 	int arreglo2[50];
  9. 	int valor[200];
  10. 	int x,i=1,j=2, temp;
  11. 	int a;
  12.  
  13.  
  14. 	int valor1[23];
  15.  
  16.  
  17.  
  18.  
  19.  
  20. 	if((f=fopen(nombre,"rt+"))==NULL)
  21. 	 {
  22. 	  printf("\nEL FICHERO NO EXISTE.");
  23. 	  getch();
  24. 	  exit(0);
  25. 	  }
  26.  
  27. 	  while(!feof(f)&&!exit)
  28. 	 {
  29. 	  fread(&datos, sizeof(datos),1,f);
  30.  
  31.  
  32. 	  valor1[nclaves]=atoi(datos.clave);
  33. 	  nclaves=nclaves+1;
  34. 	 }
  35.  
  36. 	  if(valor1[i]>valor1[j])
  37. 	    {
  38. 	     valor[j]=aux;
  39. 	     valor[i]=valor[j];
  40. 	     valor[j]=valor[i];
  41. 	     j++;
  42. 	     i++;
  43. 	    }
  44. 	  else
  45. 	   {
  46. 	    i++;
  47. 	    j++;
  48. 	   }
  49.  
  50. 	   for(i=1;i<=nclaves;i++)
  51. 	    {
  52. 	     printf("%d",valor[i]);
  53. 	    }
  54.  
  55. 	 fclose(f);
  56. 	 getch();
  57.  
  58.  
  59.    }

Es que el programa crea un archivo .txt y despues desde ese archivo deve de ordenarlos en el programa es lo k no me sale.. Y gracias por responder hermano ;)
En línea
Littlehorse
All the world's a stage
Moderador
***
Desconectado Desconectado

Mensajes: 2.714


Nie Dam Sie


Ver Perfil WWW
Re: Ayuda con metodo de ordenacion
« Respuesta #3 en: 18 Junio 2010, 04:51 am »
  • Es recomendable utilizar fgets en lugar de gets.
  • Tanto conio como graphics son librerías no estandar no recomendables. Es preferible utilizar funciones especificas del sistema o soluciones multi-plataforma en caso que se necesite

En cuanto al código, es bastante largo y desordenado así que tendrás que depurar, ya sea debuggeando o poniendo printf's en lugares específicos, como te sea mas cómodo.

Lo primero que se nota a simple vista en la función "ordenar" es que declaras variables y arreglos que no utilizas. Intenta ir quitando del código lo que no necesites así se te hace mas fácil seguirlo y modificarlo.
Es importante también que revises la lógica del método de ordenamiento, ya que vos vas leyendo los datos e ingresandolos en un arreglo, pero luego cuando llega el momento de ordenar, no realizas los ciclos necesarios.

En cuanto a la apertura y lectura del archivo, si vas a trabajar con los datos de esa forma, es conveniente que lo hagas en modo binario.

En conclusión, revisa donde los valores no son adecuados y donde el programa no realiza lo que debería, y también lee este link y luego compara con tu función.

Saludos
En línea
An expert is a man who has made all the mistakes which can be made, in a very narrow field.
Mr.Blue


Desconectado Desconectado

Mensajes: 441



Ver Perfil WWW
Re: Ayuda con metodo de ordenacion
« Respuesta #4 en: 18 Junio 2010, 18:40 pm »
Código
  1. valor[j]=aux;
  2. 	     valor[i]=valor[j];
  3. 	     valor[j]=valor[i];
puede ser que aca aya algo mal? o estoy confundido yo?


**Modifico
no, me equivoque yo, disculpas.
« Última modificación: 18 Junio 2010, 19:08 pm por eeprom46 » En línea
leogtz
. . .. ... ..... ........ ............. .....................
Colaborador
***
Desconectado Desconectado

Mensajes: 3.069


/^$/


Ver Perfil WWW
Re: Ayuda con metodo de ordenacion
« Respuesta #5 en: 18 Junio 2010, 18:53 pm »
Cita de: eeprom46 link=topic=297053.msg1471640#msg1471640 no me equivoque yo, disculpas.
[/quote

No te equivocaste tú, ¿entonces lo hizo el otro compañero?
En línea
Código
  1. (( 1 / 0 )) &> /dev/null || {
  2. 	echo -e "stderrrrrrrrrrrrrrrrrrr";
  3. }
  4.  
http://leonardogtzr.wordpress.com/
leogutierrezramirez@gmail.com
Rilax

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #6 en: 18 Junio 2010, 19:22 pm »
MIL gracias x sus respuestas sorry si les di un codigo con "basura" no me di cuenta es k como soy principiante pues cuando veo k no funciona simplente le pongo " / " e intento con otra cosa, aqui el codigo sin "basura"
Código
  1. #include <stdio.h>
  2. #include <conio.h>          
  3. #include <string.h>         
  4. #include <graphics.h>       
  5. #include <stdlib.h>
  6. #include <process.h>
  7. #define TAM 20
  8. #include <ctype.h>
  9. #include "graphics.h"
  10. char nombre[20];
  11. /****************************estructura principal************************/
  12. 	  struct ferreteria
  13. 		    {
  14. 		     char articulo[TAM];
  15. 		     char clave[10];
  16. 		     char precio[10];
  17. 		     char marca[10];
  18. 		    }datos;
  19. /***********************************funciones*******************************/
  20. 		       void ordenar(struct ferreteria);
  21. 		       void insertar(struct ferreteria );
  22. 		       void visualizar(struct ferreteria );
  23. 		       void buscar(struct ferreteria );
  24. 		       void modificar(struct ferreteria );
  25. 		       void borrar(struct ferreteria );
  26. 		       void acerca();
  27. 		       void articulo(struct ferreteria );
  28. 		       void precio(struct ferreteria );
  29. 		       void clave(struct ferreteria );
  30. 		       void marca(struct ferreteria );
  31. 		       int valido(char *, struct ferreteria );
  32. /***************************iniciamos el menu principal******************/
  33.        void main()
  34.     {
  35.    /*********************************iniciamos los graficos**************/
  36.  
  37. 	  int gdriver = DETECT, gmode, errorcode;
  38. 	  int midx, midy, i;
  39.  
  40. 	   initgraph(&gdriver, &gmode, "");
  41. 	   errorcode = graphresult();
  42. 	   if (errorcode != grOk)
  43. 	      {
  44. 	       printf("Error de Graficos: %s\n", grapherrormsg(errorcode));
  45. 	       printf("Presiona una tecla para continuar:");
  46. 	       getch();
  47. 	       exit(1);
  48. 	      }
  49.  
  50. 	       char opcion;
  51. 	       int salir=0;
  52.      /**************************terminamos graficas********************/
  53.        do
  54. 	{
  55.  
  56. 	  clrscr();
  57.  
  58. 	  setfillstyle(SOLID_FILL,BLUE);
  59. 	  bar(120,60,550,240);                /*primer bar 3d*/
  60. 			/*sobre el primer*/
  61.  
  62. 	  printf("\n\n\n");
  63. 	  printf("\n\n\t\tCONTROL DE FERRETERIA\n\n");
  64. 	  printf("\t\t\t1. ALTAS\n"        );
  65. 	  printf("\t\t\t2. MOSTRAR TODO\n" );
  66. 	  printf("\t\t\t3. CONSULTAR\n"    );
  67. 	  printf("\t\t\t4. MODIFICAR \n"   );
  68. 	  printf("\t\t\t5. BAJAS\n"        );
  69. 	  printf("\t\t\t6. INREGRANTE\n");
  70. 	  printf("\t\t\t7. ORDENAR\n\n"    );
  71. 	   moveto(250,300);outtext("PULSA ESC PARA SALIR");   /*pocision de esc*/
  72. 	  setfillstyle(SOLID_FILL,7);       /*color de fondo 2*/
  73. 	  bar(0,0,120,240);
  74. 	  setbkcolor(BLUE);                    /*color de fondo3*/
  75. 	  rectangle(120,60,550,240);
  76. 	  rectangle(116,56,554,244);        /*rectangulo sobre otro*/
  77. 	  rectangle(240,295,420,310);
  78. 	  rectangle(236,291,424,314);
  79.  
  80. 	  opcion=getch();
  81. 	  clrscr();
  82. 	  switch(opcion)
  83. 		   {
  84. 		    case '1':  insertar(datos);
  85. 		    break;
  86.  
  87. 		    case '2':  visualizar(datos);
  88. 		    break;
  89.  
  90. 		    case '3':  buscar(datos);
  91. 		    break;
  92.  
  93. 		    case '4':  modificar(datos);
  94. 		    break;
  95.  
  96. 		    case '5':  borrar(datos);
  97. 		    break;
  98.  
  99. 		    case '6':  acerca();
  100. 		    break;
  101.  
  102. 		   case '7':
  103. 			       ordenar(datos);
  104.  
  105. 		    case 27:  salir=1;
  106. 		    break;
  107. 		   }
  108. 	}
  109.     while(!salir);
  110. }
  111.  
  112. /**************************insertar los datos en la estructura**************/
  113.     void insertar(struct ferreteria datos)
  114.    {
  115.     clrscr();                                            /*limpiamos pantalla*/
  116.     FILE *f;
  117.     FILE *control;
  118.     int result;
  119.     char clave[10];
  120.     printf("\t\t LOS DIRECTORIOS SON \n C: \n D: \n K: \n\n");
  121.  
  122.     printf("\n INTRODUCE EL NOMBRE DE EL ARCHIVO\n");
  123.  
  124.      gets(nombre);
  125.     f=fopen(nombre,"at+");
  126.     clrscr();
  127.     if(!f)
  128. 	{
  129. 	printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
  130. 	getch();
  131. 	exit(1);
  132. 	}
  133.  
  134.  
  135. 	/*************************************************/
  136. 	printf("PARA TERMINAR LA INTRODUCCION DE REGISTROS, EN CLAVE ESCRIBE '*'\n");
  137. 	printf("CLAVE:");
  138. 	gets(clave);   fflush(stdin);
  139. 	fclose(f);
  140. 	result=valido(clave, datos);
  141. 	f=fopen(nombre,"at+");
  142. 	while(!result)
  143. 	    {
  144. 	    printf("LA CLAVE YA EXISTE\n");
  145. 	    printf("CLAVE: ");
  146. 	    gets(clave);   fflush(stdin);
  147. 	    fclose(f);
  148. 	    result=valido(clave, datos);
  149. 	    f=fopen(nombre,"at+");
  150. 	    }	strcpy(datos.clave,clave);
  151. 	 while(strcmp(datos.clave,"*"))
  152. 	{
  153.  
  154. 	printf("ARTICULO: ");
  155. 	gets(datos.articulo);   fflush(stdin);
  156. 	printf("PRECIO ");
  157. 	gets(datos.precio);   fflush(stdin);
  158.  
  159. 	printf("MARCA: ");
  160. 	gets(datos.marca);   fflush(stdin);
  161.  
  162. 	fwrite(&datos,sizeof(datos),1,f);
  163. 	fprintf(control,"%s",datos.clave);
  164. 	fprintf(control,"%s\t\t",datos.articulo);
  165. 	fprintf(control,"%s\t\t",datos.precio);
  166. 	fprintf(control,"%s\t\t\n",datos.marca);
  167.  
  168. 	clrscr();
  169. 	printf("PARA TERMINAR LA INTRODUCCION DE REGISTROS, EN CLAVE ESCRIBE '*'\n");
  170.  
  171. 	printf("CLAVE:");
  172. 	gets(clave);   fflush(stdin);
  173. 	fclose(f);
  174. 	result=valido(clave, datos);
  175. 	f=fopen(nombre,"at+");
  176. 	while(!result)
  177. 	    {
  178. 	    printf("LA CLAVE YA EXISTE\n");
  179. 	    printf("CLAVE: ");
  180. 	    gets(clave);   fflush(stdin);
  181. 	    fclose(f);
  182. 	    result=valido(clave, datos);
  183. 	    f=fopen(nombre,"at+");
  184. 	    }	strcpy(datos.clave,clave);
  185.  
  186. 	}
  187.     fclose(f);
  188.     fclose(control);
  189. }
  190. /**********************************ver los datos introducidos***************/
  191. void visualizar(struct ferreteria datos)
  192. {
  193.     clrscr();
  194.     FILE *f;
  195.  
  196.     f=fopen(nombre,"rt+");
  197.     if(!f)
  198. 	{
  199. 	printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
  200. 	getch();
  201. 	exit(1);
  202. 	}
  203.     while(fread(&datos,sizeof(datos),1,f))
  204. 	{
  205. 	printf("ARTICULO: %s\n", datos.articulo);
  206. 	printf("CLAVE: %s\n", datos.clave);
  207. 	printf("PRECIO: %s\n", datos.precio);
  208. 	printf("MARCA: %s\n", datos.marca);
  209. 	getch();
  210. 	clrscr();
  211. 	}
  212.     fclose(f);
  213. }
  214.  
  215. void buscar(struct ferreteria datos)
  216. {
  217.     clrscr();
  218.     char opcion;
  219.     int salir=0;
  220.     do
  221. 	{
  222. 	  clrscr();
  223. 		 setfillstyle(SOLID_FILL,BLUE);
  224. 		 bar(0,0,640,120);
  225. 		 printf("\t\t\t\tBUSCAR\n");
  226. 		 printf("\t\t\t\t------\n");
  227. 		 printf("\t\t\t1. ARTICULO\n");
  228. 		 printf("\t\t\t2. CLAVE\n");
  229. 		 printf("\t\t\t3. PRECIO\n");
  230. 		 printf("\t\t\t4. MARCA\n\n");
  231. 		 moveto(250,300);outtext("PULSA ESC PARA SALIR");
  232. 		 rectangle(240,295,420,310); //rectan de salir
  233. 		 rectangle(236,291,424,314); //rectan1 de salir
  234. 		 rectangle(0,0,638,120);
  235.  
  236.  
  237. 	opcion=getch();
  238. 	switch(opcion)
  239. 	    {
  240. 	    case '1':  articulo(datos);
  241. 	    break;
  242. 	    case '2':  clave(datos);
  243. 	    break;
  244. 	    case '3':  precio(datos);
  245. 	    break;
  246. 	    case '4':  marca(datos);
  247. 	    break;
  248. 	    case 27:  salir=1;
  249. 	    break;
  250. 	    }
  251. 	}
  252.     while(!salir);
  253. }
  254. /**************************FUNCION PARA MODIFICAR FERRETERIA...************/
  255. void modificar(struct ferreteria datos)
  256. {
  257.     clrscr();
  258.     FILE *f;
  259.     FILE *control;
  260.     char opcion, articulo[TAM],clave[10];
  261.     int salir=0,salirf=0, encontrado=0;
  262.     do
  263. 	{
  264. 	system("cls");
  265. 	f=fopen(nombre,"rt+");
  266.  
  267. 	printf("INGRESA LA CLAVE A MODIFICAR: ");
  268. 	gets(clave);   fflush(stdin);
  269. 	fread(&datos,sizeof(datos),1,f);
  270. 	while(!feof(f)&&!salir)
  271. 	    {
  272. 	    if(!strcmp(datos.clave,clave))
  273. 		{
  274. 		printf("ARTICUL0 (antiguo): %s\n", datos.articulo);
  275. 		printf("ARTICULO (nuevo): ");
  276. 		gets(datos.articulo);   fflush(stdin);
  277. 		printf("CLAVE (antiguo): %s\n", datos.clave);
  278. 		printf("CLAVE (nuevo): ");
  279. 		gets(datos.clave);   fflush(stdin);
  280. 		printf("PRECIO (antiguo): %s\n", datos.precio);
  281. 		printf("PRECIO(nuevo): ");
  282. 		gets(datos.precio);   fflush(stdin);
  283. 		printf("MARCA (antiguo): %s\n", datos.marca);
  284. 		printf("MARCA (nuevo): ");
  285. 		gets(datos.marca);   fflush(stdin);
  286. 		fseek(f,-(long)sizeof(datos),SEEK_CUR);
  287. 		fwrite(&datos,sizeof(datos),1,f);
  288.  
  289. 		fwrite(&datos,sizeof(datos),1,control);
  290. 		encontrado=1;
  291. 		salir=1;
  292. 		}
  293. 	    else
  294. 		 fread(&datos,sizeof(datos),1,f);
  295.  
  296. 	    }
  297. 	if(!encontrado)
  298. 	    printf("NO SE HA ENCONTRADO EL REGISTRO QUE BUSCA\n");
  299. 	fclose(f);
  300.  
  301. 	printf("¨DESEA MODIFICAR OTRO REGISTRO? (S/N)?\n");
  302. 	opcion=toupper(getch());
  303. 	if(opcion=='N')
  304. 	    salirf=1;
  305. 	else
  306. 	    salir=0;
  307. 	}
  308.     while(!salirf);
  309. }
  310.  
  311. void borrar(struct ferreteria datos)
  312. {
  313.     clrscr();
  314.     FILE *f, *f_temp;
  315.     char opcion, clave[10];
  316.     int salir=0;
  317.     do
  318. 	{
  319. 	system("cls");
  320. 	f=fopen(nombre,"rt+");
  321. 	f_temp=fopen("ferreteria_temp","wt+");
  322. 	if(!f)
  323. 	    {
  324. 	    printf("ERROR EN LA APERTURA DEL ARCHIVO\n");
  325. 	    getch();
  326. 	    exit(1);
  327. 	    }
  328. 	if(!f_temp)
  329. 	    {
  330. 	    printf("ERROR EN LA APERTURA DEL ARCHIVO TEMPORAL\n");
  331. 	    getch();
  332. 	    exit(1);
  333. 	    }
  334. 	printf("INGRESA LA CLAVE A BORRAR: ");
  335. 	gets(clave);   fflush(stdin);
  336. 	fread(&datos,sizeof(datos),1,f);
  337. 	while(!feof(f))
  338. 	    {
  339. 	    if(strcmp(clave,datos.clave))
  340. 		fwrite(&datos,sizeof(datos),1,f_temp);
  341. 	    fread(&datos,sizeof(datos),1,f);
  342. 	    }
  343. 	fclose(f);
  344. 	fclose(f_temp);
  345. 	remove(nombre);
  346. 	rename("ferreteria_temp",nombre);
  347. 	printf("¨DESEA BORRAR OTRO REGISTRO? (S/N)\n");
  348. 	opcion=toupper(getch());
  349. 	if(opcion=='N')
  350. 	    salir=1;
  351. 	}
  352.     while(!salir);
  353. }
  354.  
  355. void acerca()
  356. {   clrscr();
  357. 		 setfillstyle(SOLID_FILL,BLUE);
  358. 		 bar(26,76,604,184);
  359. 		 rectangle(26,76,604,184);
  360. 		 gotoxy(5,5); printf("PROYECTO PARA EXTRAORDENARIO POR:\n\n");
  361. 		 printf("\tLuis Antonio Vallejo Salgado\n");
  362. 		 rectangle(30,80,600,180);
  363. 		 moveto(250,300);outtext("PULSA ESC PARA SALIR");
  364. 		 rectangle(240,295,420,310);
  365. 		 rectangle(236,291,424,314);
  366. 		 getch();
  367. }
  368. /***********************************funcion de el articulo a escribir*******/
  369.    void articulo(struct ferreteria datos)
  370.      {
  371. 	 clrscr();
  372. 	 FILE *f;
  373. 	 char articulo[TAM], opcion;
  374. 	 int salir=0, encontrado=0;
  375.       do
  376. 	{
  377. 	system("cls");
  378. 	f=fopen(nombre,"rt+");
  379. 	if(!f)
  380. 	    {
  381. 	    printf("ERROR EN LA APERTURA DEL ARCHIVO\n");
  382. 	    getch();
  383. 	    exit(1);
  384. 	    }
  385. 	printf("INGRESA EL ARTICULO A BUSCAR: ");
  386. 	gets(articulo);   fflush(stdin);
  387. 	while(fread(&datos,sizeof(datos),1,f))
  388. 	    {
  389. 	    if(!strcmp(datos.articulo,articulo))
  390. 		{
  391. 		printf("ARTICULO %s\n", datos.articulo);
  392. 		printf("CLAVE: %s\n", datos.clave);
  393. 		printf("PRECIO: %s\n", datos.precio);
  394. 		printf("MARCA: %s\n\n", datos.marca);
  395. 		encontrado=1;
  396. 		}
  397. 	    }
  398. 	if(!encontrado)
  399. 	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
  400. 	    printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)\n");
  401. 	    opcion=toupper(getch());
  402. 	    if(opcion=='N')
  403. 	    salir=1;
  404. 	else
  405. 	    encontrado=0;
  406. 	fclose(f);
  407. 	}
  408.     while(!salir);
  409. }
  410.  /***************************funcion de el precio *************************/
  411.       void precio(struct ferreteria datos)
  412.       {
  413. 	   clrscr();
  414. 	   FILE *f;
  415. 	   char opcion, precio[10];
  416. 	   int salir=0, encontrado=0;
  417. 	do
  418. 	  {
  419. 	   system("cls");
  420. 	   f=fopen(nombre,"rt+");
  421. 	   if(!f)
  422. 	    {
  423. 	     printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
  424. 	     getch();
  425. 	     exit(1);
  426. 	    }
  427. 	  printf("INTRODUCE EL PRECIO A BUSCAR: ");
  428. 	  gets(precio);   fflush(stdin);
  429. 	  while(fread(&datos,sizeof(datos),1,f))
  430. 	    {
  431. 	     if(!strcmp(precio,datos.precio))
  432. 		{
  433. 		 printf("ARTICULO: %s\n", datos.articulo);
  434. 		 printf("CLAVE: %s\n", datos.clave);
  435. 		 printf("PRECIO: %s\n", datos.precio);
  436. 		 printf("MARCA: %s\n\n", datos.marca);
  437. 		 encontrado=1;
  438. 		}
  439. 	    }
  440. 	if(!encontrado)
  441. 	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
  442. 	printf("¨DESEA BUSCAR OTRO REGISTRO (S/N)\n");
  443. 	opcion=toupper(getch());
  444. 	if(opcion=='N')
  445. 	    salir=1;
  446. 	else
  447. 	    encontrado=0;
  448. 	fclose(f);
  449. 	}
  450.     while(!salir);
  451. }
  452. /**************************funcion para el campo clave y todo su desarrollo**/
  453. void clave(struct ferreteria datos)
  454. {
  455.     clrscr();
  456.     FILE *f;
  457.     char opcion, clave[10];
  458.     int salir=0, encontrado=0;
  459.     do
  460. 	{
  461. 	system("cls");
  462. 	f=fopen(nombre,"rt+");
  463. 	if(!f)
  464. 	    {
  465. 	    printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
  466. 	    getch();
  467. 	    exit(1);
  468. 	    }
  469. 	printf("INGRESA LA CLAVE A BUSCAR: ");
  470. 	gets(clave);   fflush(stdin);
  471. 	while(fread(&datos,sizeof(datos),1,f))
  472. 	    {
  473. 	    if(!strcmp(clave,datos.clave))
  474. 		{
  475. 		printf("ARTICULO: %s\n", datos.articulo);
  476. 		printf("CLAVE: %s\n", datos.clave);
  477. 		printf("PRECIO: %s\n", datos.precio);
  478. 		printf("MARCA: %s\n\n", datos.marca);
  479. 		encontrado=1;
  480. 		}
  481. 	    }
  482. 	if(!encontrado)
  483. 	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
  484. 	printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)\n");
  485. 	opcion=toupper(getch());
  486. 	if(opcion=='N')
  487. 	    salir=1;
  488. 	else
  489. 	    encontrado=0;
  490. 	fclose(f);
  491. 	}
  492.     while(!salir);
  493. }
  494. /**********************************funcion  para el campo marca*************/
  495.        void marca(struct ferreteria datos)
  496.       {
  497.        FILE *f;
  498.        char opcion, marca[10];
  499.        int salir=0, encontrado=0;
  500.        do
  501. 	 {
  502. 	  system("cls");
  503. 	  f=fopen(nombre,"rt+");
  504. 	  if(!f)
  505. 	      {
  506. 	       printf("ERROR EN LA APERTURA DE EL ARCHIVO\n");
  507. 	       getch();
  508. 	       exit(1);
  509. 	      }
  510. 	       printf("INGRESA LA MARCA A BUSCAR: ");
  511. 	       gets(marca);   fflush(stdin);
  512. 	       while(fread(&datos,sizeof(datos),1,f))
  513. 		{
  514. 		 if(!strcmp(marca,datos.marca))
  515. 		      {
  516. 			printf("ARTICULO: %s\n", datos.articulo);
  517. 			printf("CLAVE: %s\n", datos.clave);
  518. 			printf("PRECIO: %s\n", datos.precio);
  519. 			printf("MARCA: %s\n\n", datos.marca);
  520. 			encontrado=1;
  521. 		      }
  522. 		}
  523. 	if(!encontrado)
  524. 	    printf("NO SE HA ENCONTRADO EL REGISTRO SOLICITADO\n");
  525. 	printf("¨DESEA BUSCAR OTRO REGISTRO? (S/N)?\n");
  526. 	opcion=toupper(getch());
  527. 	if(opcion=='N')
  528. 	    salir=1;
  529. 	else
  530. 	    encontrado=0;
  531. 	fclose(f);
  532. 	}
  533.     while(!salir);
  534. }
  535.  
  536. /***********esta funcion es para ver si el archivo esta bien hecho o no****/
  537. int valido(char clave[], struct ferreteria datos)
  538. {
  539.     FILE *f;
  540.     int esvalido=1;
  541.     f=fopen(nombre,"rt+");
  542.     fread(&datos,sizeof(datos),1,f);
  543.     while(!feof(f)&&esvalido)
  544. 	{
  545. 	if(!strcmp(clave,datos.clave))
  546. 	    esvalido=0;
  547. 	else
  548. 	    fread(&datos,sizeof(datos),1,f);
  549. 	}
  550.     fclose(f);
  551.     return esvalido;
  552. }
  553.  
  554.  
  555. /***************************ordenar las claves por m. de burbuja*************************************/
  556.  
  557.  
  558. 	void ordenar(struct ferreteria datos)
  559.        {
  560.  
  561. 	FILE *f;
  562. 	int p, aux;
  563. 	int nclaves=1;
  564. 	int arreglo1[50];
  565. 	int arreglo2[50];
  566. 	int valor[200];
  567. 	int x,i=1,j=2, temp;
  568. 	int a;
  569.  
  570.  
  571. 	int valor1[23];
  572.  
  573.  
  574. 	if((f=fopen(nombre,"rt+"))==NULL)
  575. 	 {
  576. 	  printf("\nEL FICHERO NO EXISTE.");
  577. 	  getch();
  578. 	  exit(0);
  579. 	  }
  580.  
  581. 	  while(!feof(f)&&!exit)
  582. 	 {
  583. 	  fread(&datos, sizeof(datos),1,f);
  584.  
  585.  
  586. 	  valor1[nclaves]=atoi(datos.clave);
  587. 	  nclaves=nclaves+1;
  588. 	 }
  589.  
  590. 	  if(valor1[i]>valor1[j])
  591. 	    {
  592. 	     valor[j]=aux;
  593. 	     valor[i]=valor[j];
  594. 	     valor[j]=valor[i];
  595. 	     j++;
  596. 	     i++;
  597. 	    }
  598. 	  else
  599. 	   {
  600. 	    i++;
  601. 	    j++;
  602. 	   }
  603.  
  604. 	   for(i=1;i<=nclaves;i++)
  605. 	    {
  606. 	     printf("%d",valor[i]);
  607. 	    }
  608.  
  609. 	 fclose(f);
  610. 	 getch();
  611.  
  612.  
  613.    }

Littlehorse, se ve k sabes mucho, e checar lo que me dijste y pus sigue sin jalar :S

sobre lo de
Código
  1. valor[j]=aux;
  2. 	     valor[i]=valor[j];
  3. 	     valor[j]=valor[i];

Segun yo sta bien...
En línea
Nork

Desconectado Desconectado

Mensajes: 196



Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #7 en: 19 Junio 2010, 21:17 pm »
Yo no usaría el método de la burbuja. Supongo que lo habrás usado por que es el que más te sonaba ya que se habla mucho de él... pero es de lo peor en cuanto a sistemas de ordenación (tiempo n^2). Si me dejas darte mi opinión usa el sort que te viene en la librería algorithm y su tiempo es de lo mejor (logn*n), aparte es muy fácil de usar!
En línea
C' Est La Vie
Rilax

Desconectado Desconectado

Mensajes: 4


Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #8 en: 21 Junio 2010, 06:36 am »
ya lo solucione:

Código
  1. void ordenar(struct ferreteria datos)
  2. {
  3.       FILE *f;
  4.       char clave[10];
  5.       int nclaves=0;
  6.       int valor1[23];
  7.  
  8.       int i,n,m,j,p;
  9.  
  10.  
  11.  
  12.       if((f=fopen(nombre,"r"))==NULL) 
  13.       {
  14.          printf("\nEL FICHERO NO EXISTE.");
  15.          getch();
  16.          exit(0);
  17.       }
  18.  
  19.       nclaves=0;
  20.  
  21.       fread(&datos, sizeof(datos),1,f); 
  22.       while(!feof(f))
  23.       {
  24.  
  25.         valor1[nclaves]=atoi(datos.clave);
  26.         fread(&datos, sizeof(datos),1,f); 
  27.         nclaves++;
  28.       }
  29.  
  30.  
  31.  
  32.  
  33.      for(i=0;i<nclaves;i++){
  34.         for(j=0;j<nclaves-1;j++){
  35.           if(valor1[i]<valor1[j]){
  36. 	     m=valor1[i];
  37.              valor1[i]=valor1[j];
  38. 	     valor1[j]=m;
  39.           }
  40.         }
  41.      }
  42.  
  43.     printf("Claves Ordenadas.....\n");    
  44.  
  45.     for (i=0;i<nclaves; i++)
  46.     {
  47.        printf("clave: %d  \n", valor1[i]);
  48.     }
  49.          getch();
  50.  
  51.    fclose(f);
  52.  
  53. }
  54.  
  55.  

Gracias por todas y cada una de sus respuestas ;)
En línea
cbug

Desconectado Desconectado

Mensajes: 147



Ver Perfil
Re: Ayuda con metodo de ordenacion
« Respuesta #9 en: 21 Junio 2010, 15:45 pm »
Tengo unas dudas:

1- ¿Por qué pasas como parámetro datos, directamente no sería mejor declararlo localmente si para lo único que lo utilizas es para leer datos del archivo?
2-¿Por qué ordenas si todo es en ámbito local y al salir se pierde la ordenación?
En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda con ordenación plis!
Programación C/C++ 		mihina 1 1,988 Último mensaje 22 Febrero 2011, 13:25 pm
por mihina
Ordenación método de la burbuja
Programación C/C++ 		neveldine 3 2,577 Último mensaje 9 Diciembre 2015, 23:04 pm
por neveldine
Ayuda con una ordenacion de un array please? :P
Programación C/C++ 		valeeen 6 2,613 Último mensaje 13 Diciembre 2015, 20:01 pm
por valeeen
Método de ordenación por inserción en c
Programación C/C++ 		Adry_cr23 1 1,653 Último mensaje 19 Abril 2018, 23:54 pm
por MAFUS
Ayuda con problemas de backtracking, algoritmos de ordenación y búsqueda en C
Programación C/C++ 		Albpenu 1 2,652 Último mensaje 27 Mayo 2021, 21:19 pm
por Eternal Idol
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines