En el siguiente programa quise hacer que la lista se ordene con la funcione ordenar pero no funciona y no logro darme cuenta porque, la función insertar, inserta nodos pero no siempre lo hace ordenadamente, y la función borrar a veces borra y otras no.
Quería que si alguno de ustedes logra darse cuanta cual es el error me avise, y de paso le aportamos la solución al sitio Utnianos.


Aquí va el codigo:

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <math.h>



struct nodo

{

    int dato;

    char nombre[20];

    struct nodo *sig;

};



typedef struct nodo Nodo;

typedef struct nodo *Ptrnodo;



Ptrnodo crear_nodo (void);

void insertar_nodo (Ptrnodo *lista);

void imprimir_lista (Nodo *lista);

void insertar_ordenados (Ptrnodo *lista);

void borrar_nodo (Ptrnodo *lista, int dato);

void ordenar_lista(Ptrnodo *lista);

//----------------------------------





void main (void)

{

  int i=0,dato;

  

  Ptrnodo Lista = NULL;

  

  for (i=0;i<4;i++)

    insertar_ordenados (&Lista);

  

  imprimir_lista (Lista);

  

  ordenar_lista(&Lista);

  

  imprimir_lista (Lista);

  //printf("ingrese el numero a borrar");

  //scanf("%d",&dato);

  //borrar_nodo (&Lista,dato);

  

  //imprimir_lista (&Lista);

  



}



//funciones



Ptrnodo crear_nodo (void)

{

  Ptrnodo Nuevo;

  Nuevo = malloc(sizeof(Nodo));

  printf("Ingrese DATO   Nombre");

  fscanf(stdin,"%d %s",&Nuevo->dato,Nuevo->nombre);

  Nuevo->sig = NULL;

  return Nuevo;

}





void insertar_nodo (Ptrnodo *lista)

{

  Ptrnodo Nuevo;

  Nuevo = crear_nodo();



  Nuevo->sig = *lista;

  *lista = Nuevo;  

}



void imprimir_lista (Nodo *lista)

{

  

  

  while (lista != NULL)

  {

    printf("%d %s ->",lista->dato,lista->nombre);

    lista = lista->sig;

  }

   

}





//--------------------------------------------------------

void insertar_ordenados (Ptrnodo *lista)

{

    Ptrnodo Ant,Nuevo,Act;

    

     

    Act = NULL;

    Nuevo = (Nodo *)malloc(sizeof(Nodo));

    if (Nuevo != NULL)

      printf("error");

    //Nuevo->sig = NULL;

    

    printf("Ingrese DATO   Nombre");

    fflush(stdin);

    fscanf(stdin,"%d %s",&Nuevo->dato,Nuevo->nombre);

    

    

    if(*lista == NULL || (*lista)->dato > Nuevo->dato)		//si la lista vacia o el dato ingresado es menor

      {

	

	Nuevo->sig = *lista;

	*lista = Nuevo; 

      }

    else   

    {//insertar despues del nodo especificado por anterior conservando el orden

	  

	  Ant = *lista;

	  while(Ant->dato < Nuevo->dato && Ant!=NULL)// != NULL) //mientras no llego al final

	    {

	     

	     Nuevo->sig = Ant->sig;

	      Ant->sig = Nuevo;

	      Ant = Ant->sig;

	    } 



	}

}

//-----------------------------------------------------------

void ordenar_lista(Ptrnodo *lista)

{

  Ptrnodo Aux;

  Ptrnodo Ant;

  Ptrnodo Act;

  

  Aux = NULL;

  Ant = *lista;

  Act = Ant->sig;

  



  while(Act != NULL)

  {

    if(Ant->dato < Act->dato)

    {

      Aux = Act;

      Act = Ant;

      Ant = Aux;

    }

    

    Act = Act->sig;

    Ant = Ant->sig;



  }

  

  

}



//-----------------------------------------------------------

void borrar_nodo (Ptrnodo *lista, int val)

{

  Ptrnodo Ant,nodo;

  

  Ant = *lista;

  

  if(*lista == NULL)

    printf("no hay datos para borrar");

  else

  {

    while(Ant->dato < val && Ant != NULL)

    {

      //if(Ant)

      nodo = Ant->sig;

      Ant->sig = nodo->sig;

      free(nodo);

      

      Ant = Ant->sig;

    }



  }



}

No tengo ahora tiempo de ver tu código, estoy estudiando pero te facilito mi código que hice hace un tiempo.
Funciona re bien y no pincha por ninguna parte o al menos al día de hoy no pincho, fijate si lo entendes y espero que sirva hasta que alguno te de una mejor respuesta, saludos.

 /**

 * \fn void ordenar_lista(DATO **lista)

 * \brief Ordena la lista.

 * \author F.E.P

 * \date 8/04/12

 * \param **lista lista de elementos.

 */



void ordenar_lista(DATO **lista){

	

	DATO *listaordenada = NULL; //aca guardo la lista como la voy ordenando.

	DATO *aux;           //Este es para recorrer la lista y no perder la referencia.

	int contenido;       //contiene el valor que saco de la lista para ubicar en la nueva ordenada.

	

	aux = *lista;

	while(aux!=NULL){

		contenido = eliminar_primer_nodo(&aux);

		insertar_ordenado(&listaordenada, contenido);

	}

	*lista = listaordenada;

	

}





/**

 * \fn int insertar_ordenado(DATO **listaordenada,int contenido)

 * \brief Inserta en una nueva lista el valor que voy recibiendo en los nodos.

 * \author F.E.P

 * \date 8/04/12

 * \param **listaordenada puntero a la lista que esta ordenada

 * \param contenido contenido a guardar en el nodo de la lista ordenada

 * \return -1 si salio mal, 1 si salio bien.

 */



int insertar_ordenado(DATO **listaordenada,int contenido){

	

	DATO *nuevo_nodo = NULL;  //nodo para el nuevo dato.

	DATO *aux = NULL;         //para recorrer la lista sin perder la referencia de la lista.

	DATO *ant = NULL;         //para recorrer la lista y poder realizar el agregado de nodo.

	

	nuevo_nodo = (DATO *) malloc(sizeof(DATO));

	if(nuevo_nodo == NULL){

		printf("Error al pedir memoria");

		return(-1);

	}

	

	nuevo_nodo->valor = contenido;

	nuevo_nodo->siguiente = NULL;

	

	if(*listaordenada == NULL){  //Si todavia no ingrese ningun nodo..

		*listaordenada = nuevo_nodo;

		return(1);

	}

	else{  //Si ya habia ingresado nodos...

		aux = *listaordenada;

		

		while((aux != NULL)&&((aux->valor) < contenido)){  //mientras contenido no supere al valor del nodo actual.

			ant = aux;

			aux = aux->siguiente;     //apunto al siguiente nodo.

		}

		

		if(ant == NULL){                     //Si se mete al principio de la lista.

			nuevo_nodo->siguiente = *listaordenada;

			*listaordenada = nuevo_nodo;

		}

		

		else{                               //Si se mete en el medio de la lista.

			ant->siguiente = nuevo_nodo;

			nuevo_nodo->siguiente = aux;

		}

		return(1);

	}

}





/**

 * \fn int eliminar_primer_nodo(DATO **aux)

 * \brief Elimina el primer nodo de la lista a ordenar.

 * \author F.E.P

 * \date 8/04/12

 * \param **aux direccion de memoria contenida por la direccin de lista.

 * \return contenido del primer nodo.

 */



int eliminar_primer_nodo(DATO **aux){

	

	DATO *cambio_posicion = NULL; //para no tener problemas con el asterisco de aux.

	DATO *temp = NULL;            //para el free.

	int contenido;                //contenido del nodo de lista.

	

	cambio_posicion = *aux;

	temp = *aux;

	contenido = cambio_posicion->valor;

	*aux = cambio_posicion->siguiente;

	free(temp);

	return(contenido);

}

(21-09-2012 19:01)andrestecno escribió:  En el siguiente programa quise hacer que la lista se ordene con la funcione ordenar pero no funciona y no logro darme cuenta porque, la función insertar, inserta nodos pero no siempre lo hace ordenadamente, y la función borrar a veces borra y otras no.
Quería que si alguno de ustedes logra darse cuanta cual es el error me avise, y de paso le aportamos la solución al sitio Utnianos.


Aquí va el codigo:

 

void ordenar_lista(Ptrnodo *lista)

{

  Ptrnodo Aux;

  Ptrnodo Ant;

  Ptrnodo Act;

  

  Aux = NULL;

  Ant = *lista;

  Act = Ant->sig;

  



  while(Act != NULL)

  {

    if(Ant->dato < Act->dato)

    {

      Aux = Act;

      Act = Ant;

      Ant = Aux;

    }

    

    Act = Act->sig;

    Ant = Ant->sig;



  }

}

Compilar y ejecutar código

Esta mal conceptualmente esto andres.
Si queres ordenar de esta forma tenes que trabajar sobre los enlaces entre los nodos (los punteros hacia otros nodos) no sobre los nodos en si.

Se entiende?

Verdaderamente no me queda claro lo que me decís JulianD, yo pensaba que estaba trabajando con los enlaces.

Te recomiendo que lo hagas de la forma en que te dijo feer (aunque no es muy generica, solo sirve para un tipo de nodo que adentro contiene un int).

Pero si queres ir por este lado:
Vos tenes nodos conectados entre si por "struct nodo *sig", esos son tus enlaces.
Son los punteros que te llevan de un nodo al otro.
Usando 4 punteros a nodo para guardar las posiciones de los nodos:

Anterior al primero que queres cambiar
El primero que queres cambiar
El segundo que queres cambiar
El siguiente al segundo que queres cambiar

Y redefiniendo los punteros a nodo, en base a esos que guardaste para darle el orden que queres a la lista, estarias haciendo una funcion de intercambio de nodos.
Despues esa funcion la podes usar en un metodo de ordenamiento de burbuja por ejemplo..

Pero mejor, no te compliques..
Si te interesa puedo hacerte algun grafiquito, porque dudo que se entienda algo de todo este palabrerio.

Igualmente, te vuelvo a recomendar que lo hagas de la otra forma es menos generica, pero mas intuitiva.

De todas formas, una vez que una funciona cambiar los tipos de datos es lo de menos..

Off-topic:

Siempre y cuando tengas un dato

Jajaj.. Si tenes una estructura con 100 variables adentro que haces?
Si, se podria definir una estructura igual, cargarla y devolverla.. Pero sigue siendo para un caso en particular.

Yo ya me lo aprendi de la otra manera, y estas cosas una vez que las agarras ni en pedo las queres volver a aprender de otra manera jaja

Es que... convengamos que es como un poco loco...
Tengo entendido que un burbujeo esta mal en c... Y bueno es como todo una vez que uno arma un código de una forma, al menos que el otro lo supere ampliamente es mejor lo conocido

(21-09-2012 20:54)JulianD escribió:  Te recomiendo que lo hagas de la forma en que te dijo feer (aunque no es muy generica, solo sirve para un tipo de nodo que adentro contiene un int).

Pero si queres ir por este lado:
Vos tenes nodos conectados entre si por "struct nodo *sig", esos son tus enlaces.
Son los punteros que te llevan de un nodo al otro.
Usando 4 punteros a nodo para guardar las posiciones de los nodos:

Anterior al primero que queres cambiar
El primero que queres cambiar
El segundo que queres cambiar
El siguiente al segundo que queres cambiar

Y redefiniendo los punteros a nodo, en base a esos que guardaste para darle el orden que queres a la lista, estarias haciendo una funcion de intercambio de nodos.
Despues esa funcion la podes usar en un metodo de ordenamiento de burbuja por ejemplo..

Pero mejor, no te compliques..
Si te interesa puedo hacerte algun grafiquito, porque dudo que se entienda algo de todo este palabrerio.

Igualmente, te vuelvo a recomendar que lo hagas de la otra forma es menos generica, pero mas intuitiva.

Me gustaría hacerlo por el método de la burbuja, pero todavía no me queda claro porque hacen falta tantos punteros, me vendría bien un gráfico.

Mira.. ayer despues de esto me quede haciendo la funcion de swap y una burbuja aplicada a listas dobles para ver como salia.
La verdad no te lo recomiendo para nada..

Yo necesitaba un burbujeo que me ordene una lista doble de forma que los nombres que esta contenia queden ordenados alfabeticamente, para esto use la funcion strcmp: http://c.conclase.net/librerias/?ansifun=strcmp

Ahora no tengo tiempo de explicartelo a fondo, pero te dejo las funciones de insert, imprimir lista, swap y de ordenamiento..
Te tendrias que armar un main llamandolas.

Revisalas, pensalas y despues me preguntas:

(igual todavia sigue teniendo un error recontra aleatorio, pero me sirve asi como esta )

 #include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct lista{ 

  char * nombre; 

  struct lista * prox; 

  struct lista * prev;

} Nodo;



void insert ( Nodo **lista , char *nombre);



void imprimir_lista (Nodo *lista);



void ordenar (Nodo **lista);



void swap_actnext (Nodo **lista, char *nombre );

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



void insert ( Nodo **lista , char *nombre) {

  

  Nodo *nuevo, *act;

  

  if ( (nuevo=(Nodo*) malloc (sizeof(Nodo))) == NULL ) {

    printf ("\nNo hay memoria disponible\n");

    return;

  }

  

  if ( (nuevo->nombre= (char*) malloc (strlen (nombre))) == NULL){

    printf ("\nNo hay memoria disponible\n");

    return;

  }

  

  strcpy (nuevo->nombre,nombre); /** Cargo la cadena en el nodo nuevo */

  

  act=*lista; /** Utilizo 'act' para desplazarme */

  

  if (!*lista) { /** En caso de que la lista este vacia. 'Nuevo' pasa a ser el primer elemento */

    *lista=nuevo;

    nuevo->prox=NULL;

    nuevo->prev=NULL;

    return;

  }

  

  while (act->prox!=NULL) /** Busco el ultimo elemento, para colocar 'nuevo' a continuacion */

    act=act->prox;

  

  act->prox=nuevo;

  nuevo->prox=NULL;

  nuevo->prev=act;

  return;

  

}



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



void imprimir_lista (Nodo *lista) {

  

  Nodo *aux=lista;

  

 

  if (!lista) {

    printf ("\nLa lista esta vacia.\n");

    return;

  }

  

  while (lista) {

    printf ("\n%s", lista->nombre);

    lista=lista->prox;

  } 

  

  /** //Imprimir lista al reves.

  if (!aux) {

    return;

  }

  

  while (aux->prox!=NULL) 

    aux=aux->prox;

  

  while (aux) {

    printf ("\n%s", aux->nombre);

    aux=aux->prev;

  } */

  

  printf ("\n");

}



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



/* Funcion que intercambia las posiciones del nodo que contiene la cadena nombre y de su nodo posterior */



void swap_actnext (Nodo **lista, char *nombre ) {

 

  Nodo *nodo1, *nodo2, *ant1, *sig2;

  

  ant1 = NULL;

  nodo1 = *lista;

  

  if (nodo1==NULL) { /** Validacion: Intercambio de lista vacia */

    printf ("Error. Lista vacia");

    return;

  }

  

  while ((strcmp(nodo1->nombre,nombre)!=0)&&(nodo1->prox!=NULL)) { /** Busqueda */

    ant1 = nodo1;

    nodo1 = nodo1->prox;

  }

  

  if (nodo1->prox==NULL) { /** Validacion: Intercambio de ultimo nodo */

    printf ("Error: \n- No se ha encontrado un nodo con la cadena especificada.  \n- No hay nodo a continuacion del nodo especificado.\n");

    return;

  }

  

  nodo2 = nodo1->prox;

  sig2 = nodo2->prox;

  

  if (ant1==NULL) { /** Caso de que haya que intercambiar el primer y segundo elemento */

    (*lista) = nodo2;

    nodo2->prev = NULL;

  } 

  

    else {         /** Cualquier otro caso */

      ant1->prox = nodo2;

      nodo2->prev = ant1;

    }

      

   nodo2->prox = nodo1;

   nodo1->prev=nodo2;

   nodo1->prox = sig2;

   if (sig2)

    sig2->prev=nodo1;

  

}



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



void ordenar (Nodo **lista) {

  

  Nodo *aux;

  int size=0;

  int i,j;

  

  aux=*lista;

  while (aux) { /** Mido el tamaño de la lista */

    aux=aux->prox;

    size++;

  }

  

  for (i=1;i<size;i++) {

    aux=*lista;			 /** En cada nueva pasada reseteo la posicion de aux al comienzo de la lista */

    

    for (j=1;j<size;j++) {

      

	  if ((aux->prox!=NULL)&&(aux!=NULL)) {

	    

	      if((strcmp(aux->nombre,aux->prox->nombre))>0) { 		/** Criterio de comparacion */

	   	      swap_actnext (lista,aux->nombre); 		/** Intercambio */  

	      }	  

	      

	      else aux=aux->prox;     

      }

    }

  }

}

Estas practicando para un parcial o para el final de la otra semana?

(22-09-2012 14:58)JulianD escribió:  Mira.. ayer despues de esto me quede haciendo la funcion de swap y una burbuja aplicada a listas dobles para ver como salia.
La verdad no te lo recomiendo para nada..

Yo necesitaba un burbujeo que me ordene una lista doble de forma que los nombres que esta contenia queden ordenados alfabeticamente, para esto use la funcion strcmp: http://c.conclase.net/librerias/?ansifun=strcmp

Ahora no tengo tiempo de explicartelo a fondo, pero te dejo las funciones de insert, imprimir lista, swap y de ordenamiento..
Te tendrias que armar un main llamandolas.

Revisalas, pensalas y despues me preguntas:

(igual todavia sigue teniendo un error recontra aleatorio, pero me sirve asi como esta )

 #include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct lista{ 

  char * nombre; 

  struct lista * prox; 

  struct lista * prev;

} Nodo;



void insert ( Nodo **lista , char *nombre);



void imprimir_lista (Nodo *lista);



void ordenar (Nodo **lista);



void swap_actnext (Nodo **lista, char *nombre );

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



void insert ( Nodo **lista , char *nombre) {

  

  Nodo *nuevo, *act;

  

  if ( (nuevo=(Nodo*) malloc (sizeof(Nodo))) == NULL ) {

    printf ("\nNo hay memoria disponible\n");

    return;

  }

  

  if ( (nuevo->nombre= (char*) malloc (strlen (nombre))) == NULL){

    printf ("\nNo hay memoria disponible\n");

    return;

  }

  

  strcpy (nuevo->nombre,nombre); /** Cargo la cadena en el nodo nuevo */

  

  act=*lista; /** Utilizo 'act' para desplazarme */

  

  if (!*lista) { /** En caso de que la lista este vacia. 'Nuevo' pasa a ser el primer elemento */

    *lista=nuevo;

    nuevo->prox=NULL;

    nuevo->prev=NULL;

    return;

  }

  

  while (act->prox!=NULL) /** Busco el ultimo elemento, para colocar 'nuevo' a continuacion */

    act=act->prox;

  

  act->prox=nuevo;

  nuevo->prox=NULL;

  nuevo->prev=act;

  return;

  

}



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



void imprimir_lista (Nodo *lista) {

  

  Nodo *aux=lista;

  

 

  if (!lista) {

    printf ("\nLa lista esta vacia.\n");

    return;

  }

  

  while (lista) {

    printf ("\n%s", lista->nombre);

    lista=lista->prox;

  } 

  

  /** //Imprimir lista al reves.

  if (!aux) {

    return;

  }

  

  while (aux->prox!=NULL) 

    aux=aux->prox;

  

  while (aux) {

    printf ("\n%s", aux->nombre);

    aux=aux->prev;

  } */

  

  printf ("\n");

}



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



/* Funcion que intercambia las posiciones del nodo que contiene la cadena nombre y de su nodo posterior */



void swap_actnext (Nodo **lista, char *nombre ) {

 

  Nodo *nodo1, *nodo2, *ant1, *sig2;

  

  ant1 = NULL;

  nodo1 = *lista;

  

  if (nodo1==NULL) { /** Validacion: Intercambio de lista vacia */

    printf ("Error. Lista vacia");

    return;

  }

  

  while ((strcmp(nodo1->nombre,nombre)!=0)&&(nodo1->prox!=NULL)) { /** Busqueda */

    ant1 = nodo1;

    nodo1 = nodo1->prox;

  }

  

  if (nodo1->prox==NULL) { /** Validacion: Intercambio de ultimo nodo */

    printf ("Error: \n- No se ha encontrado un nodo con la cadena especificada.  \n- No hay nodo a continuacion del nodo especificado.\n");

    return;

  }

  

  nodo2 = nodo1->prox;

  sig2 = nodo2->prox;

  

  if (ant1==NULL) { /** Caso de que haya que intercambiar el primer y segundo elemento */

    (*lista) = nodo2;

    nodo2->prev = NULL;

  } 

  

    else {         /** Cualquier otro caso */

      ant1->prox = nodo2;

      nodo2->prev = ant1;

    }

      

   nodo2->prox = nodo1;

   nodo1->prev=nodo2;

   nodo1->prox = sig2;

   if (sig2)

    sig2->prev=nodo1;

  

}



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



void ordenar (Nodo **lista) {

  

  Nodo *aux;

  int size=0;

  int i,j;

  

  aux=*lista;

  while (aux) { /** Mido el tamaño de la lista */

    aux=aux->prox;

    size++;

  }

  

  for (i=1;i<size;i++) {

    aux=*lista;			 /** En cada nueva pasada reseteo la posicion de aux al comienzo de la lista */

    

    for (j=1;j<size;j++) {

      

	  if ((aux->prox!=NULL)&&(aux!=NULL)) {

	    

	      if((strcmp(aux->nombre,aux->prox->nombre))>0) { 		/** Criterio de comparacion */

	   	      swap_actnext (lista,aux->nombre); 		/** Intercambio */  

	      }	  

	      

	      else aux=aux->prox;     

      }

    }

  }

}

Compilar y ejecutar código

Estas practicando para un parcial o para el final de la otra semana?

Ahora lo voy a analizar bien y te aviso, si estoy estudiando para dar final el 2 o 3.