TDA

Es un TDA definido como:

Una colección ordenada de elementos, cuya

inserción y extracción se realiza por un

mismo extremo. Ese extremo se conoce

como “la parte superior”, la cima, o el tope

de la pila.

Codigo fuente de un programa para implemetar una pila:

/*ejemploPila.c*/

#include <stdio.h> // esta biblioteca sirve para gestionar memoria

#include <malloc.h> // esta biblioteca sirve para gestionar memoria

#ifndef Elem

#define Elem int

#endif

#include "pila.c"

/*programa principal*/

//void main (void) {

//Pila P;

//int x,n, num;

/* programa principal */

void main(void){

Pila P;

int x,n,num;

Elem e;

printf("\t\t\t***\n");

P = nuevaP();

printf("cuantos numeros quieres? :");

scanf("%i",&num);

printf("se capturaran %i numeros...\n",num);

for (x=0;x<num;x++){

printf("Dame el %i numero :",x+1);

scanf("%i",&n);

P = insertaP(n,P);

}

printf("Este es el contenido de la pila:\n");

for (x=0;x<num;x++){

e = tope(P);

printf("Elemento %i-esimo de la Pila: %i\n",x+1,e);

P = sacaP(P);

}

getch();

}

Codigo Fuente de las funciones de una Pila:

/*pila.c*/

#include <stdio.h> // esta biblioteca sirve para gestionar memoria

#include <malloc.h> // esta biblioteca sirve para gestionar memoria

#ifndef Elem

#define Elem int

#endif

/* Definicion de los tipos -las estructuras- de la Pila */

//typedef Elem int;

typedef struct celda * Pila;

struct celda {

Elem dato;

Pila sig;

};

/* Definicion de las funciones de la Pila */

Pila nuevaP();

Pila insertaP(Elem,Pila);

Pila sacaP(Pila);

int esVaciaP(Pila);

Elem tope(Pila);

/* CUERPOS DE LAS FUNCIONES */

Pila nuevaP()

{

return(NULL);

}

Pila insertaP(Elem elem,Pila pila)

{

Pila tempo;

/*Verifica que la asignacion de nueva memoria a tempo sea exitosa

* * (Pila) es una promocion de tipos de lo que regresa malloc

* * malloc gestiona memoria suficiente para un dato de tipo struct celda */

if(tempo = (Pila)malloc(sizeof(struct celda)))/*el tamaño de strcut celda en bits se le pasa a sizeof , de ahi se lo pasa a malloc como parametro para

 que verifique si hay memoria suficiente para que a tempo se le asigne como tipo pila*/

{

tempo->dato=elem; // Al campo dato de la nueva estructura se le asigna elem  operador flechita ->

tempo->sig=pila; // Al puntero sig de la nueva estructura se le hace apuntar al puntero de la pila -lo

//conecta a la pila recibida

//pila=tempo;

// Al puntero de la pila, se le hace apuntar a la nueva memoria creada, con lo que

//se actualiza y se adiciona la nueva estructura creada

}

else

printf("error(1)");

return pila;

}

Pila sacaP(Pila pila)

{

//Pila tempo;

if(esVaciaP(pila))

printf("error(5)");

else

{

Pila tempo=pila->sig;

//tempo=pila->sig;

free(pila);

pila=tempo;

}

return(pila);

}

int esVaciaP(Pila pila)

{     //-

// if (pila == NULL)    |

// return 1;       |- //es lo mismo q  return(!pila);

//else |

// return 0; |

//       -

return(!pila);

}

Elem tope(Pila pila)

{

if(esVaciaP(pila))

printf("error(5)");//

return(pila->dato);

}

/*Pila saceE(Pila pila){

printf("El elemento de la cima es %i", tope(pila);

pila = sacaP(pila);

}*/