Foro de elhacker.net

Hola que tal estoy teniendo algunos problemas para mostrar los valores de una pila una vez se ha borrado un valor, y posteriormente luego cuando voy a borrar los nodos restantes. Aqui va el codigo, espero una ayuda gracias:

#include <stdio.h>
#include <stdlib.h>
 
typedef struct nodo
{
    int num;
    struct nodo *sig;
}Nodo;
 
typedef struct pila
{
    Nodo *primero;
    Nodo *ultimo;
}Pila;
 
void resetPila( Pila * );
int estaVacia( Pila * );
void agregarValor( Pila *, int );
void mostrarPila( Pila * );
int borrarTope( Pila * );
void borrarTodo( Pila * );
 
int main( int argc, char* args[] )
{
    Pila miPila;
    int valor, opcion;
 
    resetPila( &miPila );
 
    do
    {
        system("cls");
        printf("Ingrese una opcion\n");
        printf("\n1.- Ingresar numero a la pila");
        printf("\n2.- Mostrar numeros en la pila");
        printf("\n3.- Eliminar tope de la pila");
        printf("\n4.- Salir\n\n");
        scanf("%d", &opcion);
 
        switch( opcion )
        {
            case 1:
                printf("Ingrese el numero para la pila: ");
                scanf("%d", &valor);
                agregarValor( &miPila, valor );
                system("pause");
            break;
 
            case 2:
                if( estaVacia( &miPila ) == 1 )
                    printf("\nLa pila esta vacia");
                else
                    mostrarPila( &miPila );
                system("pause");
            break;
 
            case 3:
                if( estaVacia( &miPila ) == 1 )
                    printf("\nLa pila esta vacia");
                else
                    printf("Se elimino el numero %d\n\n", borrarTope( &miPila ));
                system("pause");
            break;
 
            case 4:
                if( estaVacia( &miPila ) == 0 )
                    borrarTodo( &miPila );
            break;
        }
 
    }while( opcion != 4 );
 
 
	return 0;
}
 
void resetPila( Pila *miPila )
{
    miPila->primero = NULL;
    miPila->ultimo = NULL;
}
 
int estaVacia( Pila *miPila )
{
    if( miPila->primero == NULL )
        return 1;
    else
        return 0;
}
 
void agregarValor( Pila *miPila, int valor )
{
    Nodo *nodo;
 
    nodo = (Nodo *)malloc(sizeof(Nodo));
    nodo->num = valor;
    nodo->sig = NULL;
 
    if( estaVacia( miPila ) == 1 )
        miPila->primero = nodo;
    else
        miPila->ultimo->sig = nodo;
    miPila->ultimo = nodo;
 
}
 
void mostrarPila( Pila *miPila )
{
    Nodo *nodo;
 
    for( nodo = miPila->primero; nodo != NULL; nodo = nodo->sig )
        printf("%d\n", nodo->num);
}
 
int borrarTope( Pila *miPila )
{
    Nodo *nodo;
    int valor;
 
    if( miPila->ultimo == miPila->primero )
    {
        valor = miPila->ultimo->num;
        free( miPila->ultimo );
    }
    else
    {
        nodo = miPila->primero;
 
        while( nodo->sig != miPila->ultimo )
            nodo = nodo->sig;
 
        valor = miPila->ultimo->num;
        free( miPila->ultimo );
        miPila->ultimo = nodo;
    }
 
    return valor;
}
 
void borrarTodo( Pila *miPila )
{
    Nodo *nodo;
 
    nodo = miPila->primero->sig;
 
    while( miPila->ultimo != NULL )
    {
        free( miPila->primero );
        miPila->primero = nodo;
        if( nodo != miPila->ultimo )
            nodo = nodo->sig;
    }
}
 
 

No entiendo que haces en la función borrarTope. Para eliminar el primer elemento de la pila lo único que has de hacer es:

En cualquier caso, te recomiendo crear una clase pila y añadirle un parámetro int con el tamaño de la pila, que irías actualizando según añades o eliminas un elemento de la cola.

EDITO: Te añado un enlace hacia un aporte de hace unos meses en el que publiqué las clases pila y cola implementadas por mi. No serán las clases más eficientes que veas, pero te pueden servir para hacerte una idea. Enlace: http://foro.elhacker.net/programacion_cc/aporte_c_clases_pila_y_cola-t405322.0.html;msg1906527#msg1906527 (http://foro.elhacker.net/programacion_cc/aporte_c_clases_pila_y_cola-t405322.0.html;msg1906527#msg1906527)

Gracias por el link, me pondre a leerlo, es solo que segun lei, en una pila se extrae el ultimo valor ingresado, y la solucion que me colocaste es para eliminar un elemento de una cola.

EDIT: Es decir mi puntero de nodo lo corro mientras su elemento puntero "sig" sea distinto a la ultima posicion para liberar la ultima posicion y luego hacer esa ultima posicion igual al mi puntero nodo. Pero cuando trato de mostrar despues la pila resultante, me empieza a mostrar valores locos.

El código que te he puesto hace la función POP, que es la que se encarga de eliminar el elemento superior de una pila.
Además, veo distintos errores en varias de las funciones que has programado, como por ejemplo en la función resetPila, que no te encargas de liberar la memoria de los diferentes nodos antes de perder las direcciones de memoria del primer y ultimo nodo. Tampoco te hace falta un puntero hacia el último elemento de la pila, ya que no vas a usarlo para nada (Recordemos que una pila es Last In First Out).
Mírate la clase Stack (Pila) del enlace que te he pasado, yo creo que te ayudará a entender mejor como funcionan las clases pila y cola, y si tienes alguna duda coméntalo y intentaré resolvértela.

Saludos

Bueno, en realidad el puntero "ultimo" de mi pila lo uso para ir enlazando el ultimo nodo agregado hasta ese momento con el nuevo ultimo nodo. Y mi funcion resetPila solo lo uso para el comienzo, simplemente era un inicializador de pila (Sí, debi haberle colocado otro nombre, por la confusion).

Logre acomodarlo de forma que ahora si cumple su cometido, aunque buscare maneras mas eficientes de trabajarlo, estas son las 2 funciones que modifique:

int borrarTope( Pila *miPila )
{
    Nodo *nodo;
    int valor;
 
    if( miPila->ultimo == miPila->primero )
    {
        valor = miPila->ultimo->num;
        free( miPila->ultimo );
        miPila->primero = NULL;
        miPila->ultimo = NULL;
    }
    else
    {
        nodo = miPila->primero;
 
        while( nodo->sig != miPila->ultimo )
            nodo = nodo->sig;
 
        valor = miPila->ultimo->num;
        free( miPila->ultimo );
        miPila->ultimo = nodo;
        miPila->ultimo->sig = NULL;
    }
 
    return valor;
}
 
void borrarTodo( Pila *miPila )
{
    while( miPila->primero != NULL )
    {
        Nodo *nodo;
        nodo = miPila->primero;
        miPila->primero = miPila->primero->sig;
        free(nodo);
    }
}
 

De todas maneras, gracias por haberte tomado la molestia  :)

Ahora entiendo por que haces el while en borrarTope, tienes los punteros invertidos. Si inviertes la dirección de los punteros, obtendrás una clase pila mucho más eficiente. Sigo pensando que deberías mirarte el enlace, ya que tienes mal planteada la pila.

Saludos

En realidad me acabo de dar cuenta que es suficiente un puntero que se ubique en el tope jejeje, gracias por la ayuda, y sobre C++ aun estoy en los comienzos

Acabo de modificar mis funciones de modo que solo uso ahora un puntero que se ubica en el tope

void inicializarPila( Pila *miPila )   // Ya no es resetPila ;)
{
    miPila->tope = NULL;
}
 
int estaVacia( Pila *miPila )
{
    if( miPila->tope == NULL )
        return 1;
    else
        return 0;
}
 
void agregarValor( Pila *miPila, int valor )
{
    Nodo *nodo;
 
    nodo = (Nodo *)malloc(sizeof(Nodo));
    nodo->num = valor;
 
    if( estaVacia( miPila ) == 1 )
        nodo->sig = NULL;
    else
        nodo->sig = miPila->tope;
    miPila->tope = nodo;
}
 
void mostrarPila( Pila *miPila )
{
    Nodo *nodo;
 
    for( nodo = miPila->tope; nodo != NULL; nodo = nodo->sig )
        printf("%d\n", nodo->num);
}
 
int borrarTope( Pila *miPila )
{
    Nodo *nodo;
    int valor;
 
    nodo = miPila->tope;
    valor = nodo->num;
 
    miPila->tope = miPila->tope->sig;
    free(nodo);
 
    return valor;
}
 
void borrarTodo( Pila *miPila )
{
    while( miPila->tope != NULL )
    {
        Nodo *nodo;
        nodo = miPila->tope;
        miPila->tope = miPila->tope->sig;
        free(nodo);
    }
}
 
 
 

A eso me refería cuando te decía que no necesitabas un puntero al último elemento.

Por cierto, en C++ se usa delete en vez de free (http://www.cplusplus.com/reference/new/operator%20delete/ (http://www.cplusplus.com/reference/new/operator%20delete/)) y cin/cout para la entrada/salida de datos (http://www.cplusplus.com/doc/tutorial/basic_io/ (http://www.cplusplus.com/doc/tutorial/basic_io/)).

También he visto varios system("pause"). Te recomiendo que te leas este post: "|Lo que no hay que hacer en C/C++. Nivel basico|". Enlace: http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html (http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html)

Saludos

De C++ si conozco algunas cosas basicas como el cout, cin, new, delete, pero no me he dedicado a practicarla de lleno porque en la universidad nos tienen  trabajando con C y quiero enfocarme en ello, y del system, gracias por el consejo