parentesis balanceados

[EdGomez160295]

Ayuda con el siguiente codigo en c ya que no me marca error pero creo que no esta agregando correctamente los elementos a la pila.
(es necesario usar la pila con una estructura tal cual y tambien los NodoL)
El programa debe analizar una funcion dada por el usuario y decir si los parentesis, corchetes y llaves estan balanceados; es decir, si la funcion tiene un "(" que haya un ")" y asi con los demas.


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct nodoL{
void **dato;
struct nodoL *sig;
};
typedef struct nodoL NodoL;

struct pila{
NodoL *cab;
};
typedef struct pila Pila;

Pila *creaPila(){
Pila *nvo=(Pila *)malloc(sizeof(Pila));
nvo->cab=NULL;
return nvo;
}

NodoL *creaNodoL(void *dato, NodoL *cab){
NodoL *nvo=(NodoL *)malloc(sizeof(NodoL));
nvo->dato=dato;
nvo->sig=cab;
return nvo;
}

void insertaIni(void *dato, NodoL **cab){
*cab=creaNodoL(dato,*cab);
}

NodoL *eliminaIni(NodoL **cab){
NodoL *p;
if(*cab==NULL)
return NULL;
p=*cab;
*cab=p->sig;
p->sig=NULL;
return p;
}

void push(Pila *p, void *dato){
insertaIni(dato,&(p->cab));
}

void *pop(Pila *p){
eliminaIni(&(p->cab));
}

int pila_vacia(Pila *pila)
{
return pila==NULL;
}

char *creaChar(char c){
char *nvo=(char*)malloc(sizeof(char));
*nvo=c;
return nvo;
}

int verifi(char cad[], char ca, char cc){
int i=0, bal=1;
Pila *p;
p=creaPila();
while(cad[i]!='\0' && bal==1){
if(cad[i]==ca){
push(p,(void*)creaChar(cad[i]));
}
else{
if(cad[i]==cc){
if(pila_vacia(p)!=1){
pop(p);
}
else{
bal=0;
}
}
}
i++;
}
if(bal==1 && pila_vacia(p)!=1){
bal=0;
}
while(pila_vacia(p)!=1){
pop(p);
}
return bal;
}

int main(){
char cad[100];
printf("\n\t....Verificacion de parentesis, corchetes y llaves balanceados....\n\n\n");
printf("Ingrese funcion: ");
scanf("%s",&cad);
if (verifi(cad,'(',')')==1)
printf("\n\n\nParentesis balanceados");
else
printf("\n\nParentesis no balanceados");
if (verifi(cad,'[',']')==1)
printf("\n\nCorchetes balanceados");
else
printf("\n\nCorchetes no balanceados");
if (verifi(cad,'{','}')==1)
printf("\n\nLlaves balanceadas\n\n\n");
else
printf("\n\nLlaves no balanceadass\n\n\n");
system("pause");
return 0;
}

[eferion]

Buenos días.

Lo primero, revisa las normas del foro... el código hay que decorarlo con la etiqueta que corresponda... elige el lenguaje en cuestión en el desplegable "Highlight" y pon el código dentro de las etiquetas.

Y ahora, tratando tu problema, empezamos con un consejo. En la siguiente función:

Código C:

Pila *creaPila(){
  Pila *nvo=(Pila *)malloc(sizeof(Pila));
  nvo->cab=NULL;
  return nvo;
}
 

Puedes conseguir lo mismito haciendo:

Código C:

Pila *creaPila(){
  Pila *nvo=(Pila *)calloc(1, sizeof(Pila));
  return nvo;
}
 

calloc es una función un poco más completa que malloc ya que además de reservar la memoria, inicializa la memoria reservada a 0, con lo que nvo->cab acabará apuntando a NULL sin tener que hacer nada más.

¿Por qué usar calloc en vez de malloc? porque si, en el futuro, añades nuevos punteros a la estructura, calloc se encargará de resetear toda la memoria, mientras que si usas malloc tendrás que acordarte de actualizar esta función a mano.

Luego comentas que no se añaden los elementos a la pila. Deberías hacer caso de los warning que te salen en el código. Veamos:

Código C:

char cad[100];
scanf("%s",&cad);
 

cad es un puntero, luego ese & sobra. Lo que estás escribiendo ya te digo yo que no va a dónde tu esperas que vaya.

Código C:

struct nodoL{
    void **dato;
    struct nodoL *sig;
};
 
NodoL *creaNodoL(void *dato, NodoL *cab){
  nvo->dato=dato; // <<--- puntero doble = puntero???
}
 

Aquí tenemos el ejemplo contrario... por qué dato es un puntero doble? Si tiene que ser un puntero doble no le puedes asignar un puntero simple así por las buenas.

Y para terminar....

Código C:

void *pop(Pila *p){
  eliminaIni(&(p->cab));
}
 

pop retorna un void*, luego ahí falta un return... o sobra el asterisco.

Deberías revisar el tema del doble puntero, ya que la solución cambia dependiendo de si nodoL->dato es un puntero doble o no.

Un saludo