Mensajes

Me falla la funcion de borrar en mi lista doblemente ligada circular, que puede ser?

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

enum opcion {EXIT,INSERT,FIND,DELETE,SHOW,CURR,NEXT,PREV,FINDPREV,FINDNEXT};

struct nodo {
    char nombre[40];
    struct nodo *next;
    struct nodo *prev;
};

int numNodos;
int pos;
struct nodo *head, *tail;


struct nodo *crearNodo () {
    struct nodo *x;
     
    x= (struct nodo *) malloc (sizeof (struct nodo));
    printf ("Nombre: ");
    gets (x->nombre);
    x->next=NULL;
    x->prev=NULL;
    numNodos++; 
    return x;
}
struct nodo *buscar_ant (struct nodo *act) {
    char *k= act->nombre;
     
    if (act == NULL) return NULL;

    act= act->prev;
    while (act) {
        if (strcmp (act->nombre,k) == 0)
            break;
        act= act->prev;
    }
    return act;
}
struct nodo *buscar_sig (struct nodo *act) {
    char *k= act->nombre;
     
    if (act == NULL) return NULL;

    act= act->next;
    while (act) {
        if (strcmp (act->nombre,k) == 0)
            break;
        act= act->next;
    }
    return act;
}

struct nodo *buscar (struct nodo *lista, char *k) {
   system("cls");
     struct nodo *actual;
     char aux [40];
     int p = 1;
     int encontrado = 0;
     
        actual = lista;
        system("cls");
        printf("\n Indique nombre a buscar    ");
        fflush(stdin);
        gets(aux);
        system("cls");
        while (p <= numNodos)
           { 
            if(strcmp(aux, actual->nombre)==0)
                    {
                      printf("\n %s  EXISTE", aux );
                      encontrado = 1;
                    }
                      p++;
                      actual = actual->next;
           }                                                                                       
   if (encontrado==0)   
      printf("\n %s NO EXISTE", aux );
                                                                                                                                                                                                                                   
   printf("\n\n\n\n\n\n\n");                                                                     
   system("pause");       
}


// operacion eliminar: elimina el primer nodo que coincida con la llave k
// recibe referencia del apuntador al inicio de la lista y llave a eliminar
// devuelve el nodo eliminado o null si no se encuentra el nodo

struct nodo *borrar (struct nodo *lista, char *k) {
   system("cls");
    struct nodo  *aux;
    struct nodo  *actual;
    int nodo_eliminar;
    int x;
   
    printf("\n Indique la posición del nombre  a eliminar    ");
    scanf(" %d", &nodo_eliminar);
    if(nodo_eliminar > numNodos || nodo_eliminar < 1)
       printf("ELEMENTO INEXISTENTE");
       
    if(nodo_eliminar == 1) {
       aux = lista;
       lista = lista->next;
       if(lista == NULL)
          tail = NULL;
         
    else
      lista->prev == tail;
       }
       else if(nodo_eliminar == numNodos)
       {
          aux = tail;
          tail->prev->next = tail;
          tail = tail->prev;
       }else {                                                                                                                                                                                                                     
             actual = tail;
             for(x=1; x<nodo_eliminar;++x)
               actual = actual->next;
             aux = actual;
             actual->prev->next = actual->next;
             actual->next->prev = actual->prev;
   }
   free(aux);
   numNodos--; 
}

void listar (struct nodo *lista) {
    system("cls");
     
     struct nodo *actual;
     pos=1;
     actual=lista;
     while(pos<=numNodos)
       {
          printf("<-%s->", lista->nombre);
          lista= lista->next;
          pos++;
       }
       if(numNodos==0)
           printf("\n LISTA VACIA");
       printf("\n\n\n\n\n\n\n");
       system("pause");   
}

struct nodo *insertar (struct nodo *head, struct nodo *x) {
    if (head != NULL) {
        head->prev= x;       // El antecesor al primer nodo de la lista apunta al nuevo nodo
        x->next= head;       // El sucesor del nuevo nodo apunta al primer nodo de la lista
    }
    head= x;                // El inicio de la lista apunta al nuevo nodo
     
    return head;
}
struct nodo *curr (struct nodo *actual) {
    if (actual) {
        printf ("%s\n",actual->nombre);
        return actual;
    }
    printf ("No hay nodo actual\n");
     
    return actual;
}
struct nodo *prev (struct nodo *actual) {
    if (actual && actual->prev) {
        printf ("%s\n",actual->prev->nombre);
        return actual->prev;
    }
    printf ("No hay nodo anterior\n");
     
    return actual;
}

struct nodo *next (struct nodo *actual) {
    if (actual && actual->next) {
        printf ("%s\n",actual->next->nombre);
        return actual->next;
    }
    printf ("No hay nodo siguiente\n");
     
    return actual;
}

int main ()
{
    char nombre[40];
    enum opcion op= EXIT;
    struct nodo *x,*act=NULL;
    struct nodo *head= NULL;
    struct nodo *tail= NULL;
    struct nodo *lista;
     char aux [40];
     int p = 1;
     int encontrado = 0;
     
    while (1) {
        system ("cls");
        printf ("1. Insertar\n");
        printf ("2. Buscar\n");
        printf ("3. Borrar\n");
        printf ("4. Listar\n");
        printf ("5. Actual\n");
        printf ("6. Siguiente\n");
        printf ("7. Anterior\n");
        printf ("8. Buscar anterior\n");
        printf ("9. Buscar siguiente\n");
        printf ("0. Salir\n");
        printf ("\nOpcion: ");
        scanf ("%d", &op);
        fflush (stdin);

        switch (op) {
            case INSERT:
                x= insertar (head,crearNodo ());
                if (head == NULL)   // No hay nodos
                tail= x;
                head= x;        // Head apunta al nuevo nodo
                tail->next= head;    // Siguiente del ultimo nodo apunta al primer nodo
                head->prev= tail;    // Anterior del primer nodo apunta al ultimo nodo
                act= head;      // Nodo actual apunta a primer nodo
                break;
            case FIND:
        x= buscar (head,nombre);
                break;
            case DELETE:
                x= borrar (head,nombre);
                break;             
            case SHOW:
                listar (head);
                system ("pause");
                break;
            case CURR:
                curr (act);
                system ("pause");
                break;
            case NEXT:
                act= next (act);
                system ("pause");
                break;
            case PREV:
                act= prev (act);
                system ("pause");
                break;
            case FINDNEXT:
                x= buscar_sig (act);
                if (x != NULL) {
                    printf ("Se encuentro: %s\n", x->nombre);
                    act= x;
                }
                else
                    printf ("No se encuentra: %s\n", x->nombre);
                system ("pause");
                break;
            case FINDPREV:
                x= buscar_ant (act);
                if (x != NULL) {
                    printf ("Se encuentro: %s\n", x->nombre);
                    act= x;
                }
                else
                    printf ("No se encuentra: %s\n", x->nombre);
                system ("pause");
                break;
            case EXIT:
                return;
            default:
                printf ("Opcion invalida\n");
        }
    }       
     
}


Alguna idea?

La única diferencia, es que el nodo "siguiente" del nodo final, es el primero. Y el nodo "anterior" del primer nodo, es el último. Está conectada la cola con la cabeza.

Eso sí, hay q hacer ligeros cambios. por ejemplo, no puedes hacer un:

Código (cpp) [Seleccionar] Expandir

while(ptr->next != NULL){
    // ...
    ptr = ptr->next;
}

Porque si la lsita tiene elementos, qerá un bucle infinito.
Quitando esos cambios, el resto es parecido.

Gracias por la notacion.

He desarrollado el código de mi lista doblemente ligada pero ahora quisiera implementarla de forma circular. No comprendo exactamente que diferencias tienen con la circular ya que yo lo veo de la misma manera. PD: No me lo he robado

Esta algo largo pero necesito implementarlo de varias maneras para que sea completo se que le falta pero no quiero complicarme la vida.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

enum opcion {EXIT,INSERT,FIND,DELETE,SHOW,CURR,NEXT,PREV,FINDPREV,FINDNEXT};

struct nodo {
    char nombre[40];
    struct nodo *next;
    struct nodo *prev;
};

struct nodo *crearNodo () {
    struct nodo *x;
    x= (struct nodo *) malloc (sizeof (struct nodo));
    printf ("Nombre: ");
    gets (x->nombre);
    x->next=NULL;
    x->prev=NULL;
    return x;
}

struct nodo *buscar (struct nodo *lista, char *k) {
    if (lista == NULL) return NULL;
    while (lista) {
        if (strcmp (lista->nombre,k) == 0)
            break;
        lista= lista->next;
    }
    return lista;
}

struct nodo *buscar_sig (struct nodo *act) {
char *k = act->nombre;
    if (act == NULL) return NULL;
   
     act= act->next;
     while (act) {
        if (strcmp (act->nombre,k) == 0)
        break;   
        act= act->prev;
        }
        return act;
     }


struct nodo *buscar_ant (struct nodo *act) {
char *k = act->nombre;
    if (act == NULL) return NULL;
   
     act= act->prev;
     while (act) {
        if (strcmp (act->nombre,k) == 0)
        break;   
        act= act->prev;
        }
        return act;
     }
// operacion eliminar: elimina el primer nodo que coincida con la llave k
// recibe referencia del apuntador al inicio de la lista y llave a eliminar
// devuelve el nodo eliminado o null si no se encuentra el nodo

struct nodo *borrar (struct nodo **lista, char *k) {
    struct nodo *ant, *act;
     
    if (*lista == NULL) return NULL;
     
    act= *lista;
    ant= *lista;
    while (act != NULL) {
        if (strcmp (act->nombre,k) == 0) // nodo encontrado
            break;
        ant= act;
        act= act->next;                      // avance al sig. nodo
    }
    if (act == NULL) return NULL;
     
    // Si se encontro el nodo
    if (act == *lista)  {               // Si es el primer nodo
        *lista= act->next;               // Se mueve el aptdor. al inicio de la lista al siguiente nodo
        if (act->next)
            act->next->prev= NULL;
    }
    else {
        ant->next= act->next;         // Se liga el nodo antecesor con el nodo sucesor del nodo a eliminar
        act->prev= ant;
    }
    return act;
}


void listar (struct nodo *lista) {
    if (lista == NULL) {
        printf ("Lista vacia\n");
        return;
    }
    do {
        if (lista->prev && lista->next)
            printf ("<-%s->",lista->nombre);
        else if (lista->prev == NULL && lista->next == NULL)
            printf ("%s",lista->nombre);
        else if (!lista->next)
            printf ("<-%s",lista->nombre);
        else if (!lista->prev)
            printf ("%s->",lista->nombre);
        lista= lista->next;
    }
    while (lista != NULL);
    printf ("\n");
}
struct nodo *insertar (struct nodo *head, struct nodo *x) {
    if (head != NULL) {     //Tiene elementos
        head->prev= x;       // El antecesor al primer nodo de la lista apunta al nuevo nodo
        x->next= head;       // El sucesor del nuevo nodo apunta al primer nodo de la lista
        //x->prev=
       
    }
   
    head= x;                // El inicio de la lista apunta al nuevo nodo
     
    return head;
}

struct nodo *curr (struct nodo *actual) {
    if (actual) {
        printf ("%s\n",actual->nombre);
        return actual;
    }
    printf ("No hay nodo actual\n");
     
    return actual;
}

struct nodo *prev (struct nodo *actual) {
    if (actual && actual->prev) {
        printf ("%s\n",actual->prev->nombre);
        return actual->prev;
    }
    printf ("No hay nodo anterior\n");
     
    return actual;
}
struct nodo *next (struct nodo *actual) {
    if (actual && actual->next) {
        printf ("%s\n",actual->next->nombre);
        return actual->next;
    }
    printf ("No hay nodo siguiente\n");
     
    return actual;
}
int main ()
{
    char nombre[40];
    enum opcion op= EXIT;
    struct nodo *x,*act=NULL;
    struct nodo *head= NULL;
    struct nodo *tail= NULL;
     
    while (1) {
        system ("cls");
        printf ("1. Insertar\n");
        printf ("2. Buscar\n");
        printf ("3. Borrar\n");
        printf ("4. Listar\n");
        printf ("5. Actual\n");
        printf ("6. Siguiente\n");
        printf ("7. Anterior\n");
        printf ("8. Buscar Anterior \n");
        printf ("9. Buscar Siguiente\n");
        printf ("0. Salir\n");
        printf ("\nOpcion: ");
        scanf ("%d", &op);
        fflush (stdin);

        switch (op) {
            case INSERT:
                x= insertar (head,crearNodo ());
                if (head == NULL)
                tail=x;
                tail->next=x;
                head=x;
                head->prev =tail;
                act= head;
                break;
            case FIND:
                printf ("Buscar: ");
                gets (nombre);
                act= buscar (head,nombre);
                if (act == NULL)
                    printf ("No se encuentra: %s\n", nombre);
                else
                    printf ("Se encuentra: %s\n", nombre);
                system ("pause");
                break;
            case DELETE:
                printf ("Buscar: ");
                gets (nombre);
                x= borrar (&head,nombre);
                if (x != NULL) {
                    printf ("Se elimino: %s\n", x->nombre);
                    if (x == act) act= NULL;
                }
                else
                    printf ("No se encuentra: %s\n", nombre);
                system ("pause");
                break;             
            case SHOW:
                listar (head);
                system ("pause");
                break;
            case CURR:
                curr (act);
                system ("pause");
                break;
            case NEXT:
                act= next (act);
                system ("pause");
                break;
            case PREV:
                act= prev (act);
                system ("pause");
                break;
            case FINDNEXT:   
                x= buscar_sig (act);
                if (x != NULL) {
                    printf ("Se encontro: %s\n", x->nombre);
                    act=x;
                }
                else
                    printf ("No se encuentra: %s\n", nombre);
                system ("pause");
                break;
            case FINDPREV:
        x= buscar_ant (act);
                if (x != NULL) {
                    printf ("Se encontro: %s\n", x->nombre);
                    act=x;
                }
                else
                    printf ("No se encuentra: %s\n", nombre);
                system ("pause");
                break;
            case EXIT:
                return;
            default:
                printf ("Opcion invalida\n");
        }
    }       
}


Hola realmente no se donde copiaste tu codigo pero estas haciendo todo mal.

la funcion que tienes nuevo no recibe ningun parametro y tu le estas mandando una cola.

Código [Seleccionar] Expandir

struct cola nuevo ()

Y aqui le mandas parametros anuevo

Código [Seleccionar] Expandir

nuevo(&cc);

Si gustas te dejo un link a mis videos de programacion donde le agregamos elementos a una cola usando memoria dinamica.

[youtube=640,360]https://www.youtube.com/watch?v=KZmcypaVmtI[/youtube]

Saludos!

Saludos!

Por cierto el link a tu video es sobre cola circular ? Perdona mi ignorancia

No lo copie, yo lo hice esta mal?

Código (c) [Seleccionar] Expandir

#include <stdlib.h>
#include <stdio.h>
#define MAX 10

//ENTREGAR COLA CIRCULAR

typedef struct{
struct cola *head;
    struct cola *tail;
int nodos; //contando
} colacirc ;

struct cola{
int dato;
struct cola *sig;
};

int colaVacia (colacirc *cc) {
return cc->nodos == 0;
}

int colaLlena(colacirc *cc ){
return cc->nodos == MAX;
}

struct cola nuevo (){
struct cola n;
printf("Introduce un numero");
scanf("%d", &n.dato );
return n;
}

int insertarCC(colacirc *cc, struct cola c) {
if(colaLlena(cc) == 1){
printf("La cola esta llena\n");
return 0;
}
if (colaVacia(cc) == 1)
cc->head = &c;
else
cc->tail->sig = &c;
     cc->tail=&c;
cc->nodos++;
return 1;

}

struct cola *eliminarCC(colacirc *cc){
struct cola *c;
if(colaVacia(cc) == 1){
printf("La cola esta vacian\n");
return NULL;
}
c = cc->head;
if (cc->nodos == 1 )
cc->head = cc->tail = NULL;
else cc->head = cc->head->sig;
cc->nodos--;
return c;
}


int main (){
struct cola *cc;
  nuevo(&cc);
insertarCC(&cc, 10);

return 0;

}




Este es el codigo lo que quiero hacer es poder insertar un elemento a ella, ya tengo todo lo demas solo falta eso. 

En realidad no estoy haciendo uso de la letra ñ, estoy usando poniendolo como "a n i o".
No me permiten usar arrays en el programa.


He asignado memoria como me dijiste y ahora si avanza pero cuando pide cuantos directores necesita ya se cierra.


tambien estoy haciendo uso de " (int *)&peli->año ", que en verdad no se que hace. jeje
Algun otro consejo?

Código (c) [Seleccionar] Expandir


void LeerDatosPelicula(struct pelicula *peli){
 int i=0;
peli->nombre = (char*) malloc(sizeof (char)*MAX_NOMBRE);
peli->genero = (char*) malloc(sizeof (char)*MAX_NOMBRE);
  printf("\n\n\tlEER DATOS PELICULA\n");
 printf("Pelicula: ");
   fgets(peli->nombre, MAX_NOMBRE, stdin);
fflush(stdin);
printf ("Genero: ");
fgets(peli->genero, MAX_NOMBRE, stdin);
fflush(stdin);
printf("año: ");
fflush(stdin);
scanf("%d",(int *)&peli->año);
printf("Cuantos directores?: ");
scanf("%d",peli->numDirectores);
if(peli->numDirectores < 1)   peli->numDirectores=1;
if(peli->numDirectores > 10)  peli->numDirectores=10;

for(i=0; i< peli->numDirectores; i++){
peli->directores[i]=(char*) malloc (sizeof (char)*MAX_NOMBRE);
printf("Director %d:  ",i+1);
fflush(stdin);
fgets(peli->directores[i], MAX_NOMBRE, stdin);
}

}



y cual fue el error?

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include<stdio.h>
#define MAX_NOMBRE 30

struct pelicula{
char *nombre;
char *genero;
short año;
int numDirectores;
char *directores[10];
};

void imprimirDatosPelicula(struct pelicula);
void LeerDatosPelicula( struct pelicula *peli);

int main(){
struct pelicula peli;
LeerDatosPelicula(&peli);
imprimirDatosPelicula(peli);
return 0;
}

void imprimirDatosPelicula(struct pelicula movie){
printf("PELICULA: %s\n", movie.nombre);
printf("GENERO: %s\n", movie.genero);
printf("año: %d\n", movie.año);
printf("# DIRECTOR(ES): %d \n", movie.numDirectores);
int cont = 0;
for ( ; cont < movie.numDirectores ; cont++){
printf("DIRECTOR: %s\n", movie.directores[cont]);
   }
}


void LeerDatosPelicula(struct pelicula *peli){
 int i=0;

  printf("\n\n\tlEER DATOS PELICULA\n");
 printf("Pelicula: ");
   fgets(peli->nombre, MAX_NOMBRE, stdin);
fflush(stdin);
printf ("Genero: ");
fgets(peli->genero, MAX_NOMBRE, stdin);
fflush(stdin);
printf("año: ");
scanf("%d",peli->año);
printf("Cuantos directores?: ");
scanf("%d",peli->numDirectores);
if(peli->numDirectores < 1)   peli->numDirectores=1;
if(peli->numDirectores > 10)  peli->numDirectores=10;

for(i=0; i< 1; i++){
peli->directores[i]=(char*) malloc (sizeof (char)*MAX_NOMBRE);
printf("Director %d:  ",i+1);
fflush(stdin);
gets(peli->directores[i]);
}

}




Estoy usando Devc++ y al parecer compila muy bien pero a la hora de pedir datos marca error. Alguien que me ayude.