UTNianos

Les dejo lo que se tomo en el final de Info 1 de electronica la ultima fecha de verano:

Era una lista doblmente enlzada, la condiciones era hace 2 de 3 las funciones, estaba prohibido imprimir algo por stdout, y se podia usar malloc solo una vez en el final. No se pedia nada loco la verdad, pero no habia margen de error, habia que hacer todos los returns de las funciones para que sea tomado bien el ejercicio sino te lo tomaban como mal, y a la primera cosa mal se anulaba el ejercicio.
No habia teoria.

struct nodo_S {
int dato;
struct nodo_S ant;
struct nodo_S *sig;
}

Eran tres funciones:

1) int BorrarLista (struct nodo_s **p)
Devolvía: 0 si estaba vacia
-1 si p era NULL
La cantidad de nodos borrados
O otro numero negativo en cada de otro error

2) int agregarOrdenado (struct nodo_s **p, int dato)
Devolvía: 0 si estaba vacia la lista
1 Si no estaba vacia la lista, pero se agregaba primero el nodo
2 Si se agrebaba en el medio de la lista
3 Si se agregaba en el final de la lista
-1 si p era NULL
-2 Si habia algun error con malloc
O otro numero negativo en cada de otro error

3) int BorrarNodo(struct nodo_s **p, int dato)
Devolvía: 0 si estaba vacia
1 Si se borraba el primero
2 Si se borraba en el medio de la lista
3 Si se borraba en el final de la lista
-1 si p era NULL
-2 Si no se encontraba ningun nodo
La cantidad de nodos borrados
O otro numero negativo en cada de otro error

Espero que les sirva, saludos

Muchas Gracias.

Teoría no tomaron?

Saludos.

Nop, no tomaron!

---

Chicos, en facebook subieron fotos del final. Las dejo acá asi no se pierden y quedan en el TH!

Saludos!

[attachment=10681]

[attachment=10682]

Por suerte aprobe, aunque pense que no iba a hacerlo dado que comprobar si P era NULL lo hice mal en todos. Al parecer no fueron tan estrictos en eso, de todas formas creo que era mas importante no cometer violaciones de segmento. En si no era dificil si sabias, es mas, anda dando vuelta un post que tiene el codigo de lista doblemente enlazada con todas las aplicaciones de las cuales tenias estas 3 en el final. Con ese codigo y el Deitel (100% recomendado) se saca seguro el final.

Ya que estamos subo como me quedó a mí... practicando para el final...

Gracias por el aporte!!!

 



#include <stdio.h>

#include <stdlib.h>





typedef struct nodo_S

{

  int dato;

  struct nodo_S *sig;

  struct nodo_S *ant;

} Nodo;





int liberar (Nodo**);

int agregarOrdenado (Nodo**, int);

int removerNodo (Nodo**, int);





int liberar (Nodo** p)

{

  int i;

  

  if(!p) return -1; // p es NULL

  if(!(*p)) return 0; // lista vacía



  for (i=0; (*p)!=NULL; i++)

  {

    if((*p)->sig == NULL) // Si es el último nodo

      {

	free(*p);

	*p=NULL;

      }

    else

    {

      *p = (*p)->sig;

      free((*p)->ant);

    }

    

  } // Cierro for

  

  return i;

  

} // Cierro función





int agregarOrdenado (Nodo** p, int dato)



{

  if(!p) return -1; // p es NULL



  Nodo* aux, *nuevo;

  

  if(!(nuevo=(Nodo*) malloc(sizeof(Nodo)))) return -2; // Creo nodo nuevo pero si malloc no reserva memoria retorno error



  nuevo->dato=dato;

  nuevo->sig=NULL;

  nuevo->ant=NULL;



  if(!(*p)) // lista vacía

    {

      *p = nuevo;

      return 0;      

    }

    

  if(nuevo->dato > (*p)->dato) // Inserto en el principio de la lista

  {

    nuevo->sig = *p;

    (*p)->ant = nuevo;

    (*p) = nuevo;

    return 1;

  }

  

  aux = *p;

  

  while (1)

  {

    if(nuevo->dato == aux->dato) return -3; // Retorno error en caso de igualdad



    if(nuevo->dato > aux->dato) // Inserto en el medio de la lista

    {

      nuevo->sig = aux;

      nuevo->ant = aux->ant;

      (aux->ant)->sig = nuevo;

      aux->ant = nuevo;    

      return 2;

    }

    if(aux->sig == NULL) // Inserto al final de la lista

    {

      nuevo->ant = aux;

      aux->sig = nuevo;

      return 3;

    }

    

    aux = aux -> sig;

    

  } // Cierro while

  

} //Cierro función







int removerNodo (Nodo** p, int dato)



{

  if(!p) return -1; // p es NULL

  if(!(*p)) return 0; // lista vacía



  Nodo* aux;

  

  if(dato == (*p)->dato) // coincidencia en el primer nodo

    {

      if((*p)->sig == NULL) // hay un único nodo en la lista

	{

	  free(*p);

	  *p = NULL;

	  return 1;

	}

      else // Hay más de 1 nodo en la lista

      {

	*p = (*p)->sig;

	free((*p)->ant);

	(*p)->ant = NULL;

	return 1;

      }

    } // Cierro if

  

  aux= *p;

  

  while(1)

  {

    if(aux->sig == NULL) // Si es el último nodo

      {

	if(dato == aux->dato) // Si hay coincidencia en el último nodo

	  {

	    (aux->ant)->sig = NULL;

	    free(aux);

	    return 3;

	  }

	else // No se encontró el dato en la lista

	{

	  return -2;

	}

      } // Cierro if

    

    if(dato == aux->dato) // Si hay coincidencia en el medio de la lista

    {

      (aux->ant)->sig = aux->sig;

      (aux->sig)->ant = aux->ant;

      free(aux);

      return 2;

    } // Cierro if

    

    aux = aux -> sig;

    

  } // Cierro while

  



} // Cierro función





int main (void)

{

  

  

  

  return 0;

  

}

Gracias por el aporte. No entendi bien la diferencia que hacen entre que p sea NULL y que la lista esté vacía. A mi entender serían lo mismo, y en el codigo de Vicko tampoco me queda claro qué verifica en cada caso. Si me lo explican estaria agradecido.

Saludos