como me dijo mi profe de compu



hay 2 clases de lectura de proceso

pila y cola



la cola es como cuando vas al supermercado y el primero de la cola sale primero y el ultimo ultimo



pero en la pila es como cuando apilas libros uno encima de otro allí es distinto, el que pones primero no es el primero que sale, sino el ultimo y el ultimo que has puesto es el que sale primero



espero que hayas entendido mi arcaica explicacion



sverte

Aqui esta un ejemplo que yo hice en C++



#include

#include

#include



struct pila{

int infp;

pila* sig;

};



void insertar(pila**, int);

void imprimir(pila**);

void quitar(pila**);

void vaciar(pila**);



void main()

{

pila* cima = NULL;

int dato;

char opc;

ini: clrscr();

cout << "1.-Introducir" << endl;

cout << "2.-Quitar" << endl;

cout << "3.-Imprimir Pila" << endl;

cout << "4.-Vaciar" << endl;

cout << "5.-Salir" << endl << endl << endl;



opc = getch();

switch(opc)

{

case '1':

cout << "Introduce dato: " ;

cin >> dato;

insertar(&cima, dato);

goto ini;



case '2':

quitar(&cima);

goto ini;



case '3':

imprimir(&cima);

getch();

goto ini;



case '4':

vaciar(&cima);

goto ini;



case '5':

exit(1);



default:

cout << "Tecla incorrecta";

getch();

goto ini;

}

}



void insertar(pila** insertar, int dato)

{

pila* aux = new pila;

if (aux == NULL)

{

cerr << "Pila llena";

getch();

exit(1);

}

aux -> infp = dato;

aux -> sig = *insertar;

*insertar = aux;

}



void quitar(pila** quitar)

{

if (*quitar==NULL)

{

cout << "La pila ya esta vac¡a";

exit(1);

}

else

cout << "Quitando elemento cima...";



delete *quitar;

*quitar = (*quitar)->sig;

}



void imprimir(pila** recorrer)

{

pila* indice;

if (*recorrer == NULL)

{

cout << "No hay datos";

}

for (indice = *recorrer; indice != NULL; indice = indice -> sig)

{

cout << indice->infp << endl;

}

}



void vaciar(pila** vaciar)

{

if(*vaciar == NULL)

{

cout << "Esta pila esta vac¡a";

}



else



cout << "Vaciando pila...";

while(*vaciar!=NULL)

{

delete (*vaciar);

(*vaciar) = (*vaciar)->sig;

}

delete(*vaciar);

}







pero si ocupas que sea en C, aqui esta uno que vi en internet, este nada mas te inserta los datos.



#include

#include



typedef struct _nodo {

int valor;

struct _nodo *siguiente;

} tipoNodo;



typedef tipoNodo *pNodo;

typedef tipoNodo *Pila;



/* Funciones con pilas: */

void Push(Pila *l, int v);

int Pop(Pila *l);



int main()

{

Pila pila = NULL;

pNodo p;



Push(&pila, 20);

Push(&pila, 10);

Push(&pila, 40);

Push(&pila, 30);



printf("%d, ", Pop(&pila));

printf("%d, ", Pop(&pila));

printf("%d, ", Pop(&pila));

printf("%d\n", Pop(&pila));



system("PAUSE");

return 0;

}



void Push(Pila *pila, int v)

{

pNodo nuevo;



/* Crear un nodo nuevo */

nuevo = (pNodo)malloc(sizeof(tipoNodo));

nuevo->valor = v;



/* Añadimos la pila a continuación del nuevo nodo */

nuevo->siguiente = *pila;

/* Ahora, el comienzo de nuestra pila es en nuevo nodo */

*pila = nuevo;

}



int Pop(Pila *pila)

{

pNodo nodo; /* variable auxiliar para manipular nodo */

int v; /* variable auxiliar para retorno */



/* Nodo apunta al primer elemento de la pila */

nodo = *pila;

if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */

/* Asignamos a pila toda la pila menos el primer elemento */

*pila = nodo->siguiente;

/* Guardamos el valor de retorno */

v = nodo->valor;

/* Borrar el nodo */

free(nodo);

return v;

}

Pilas en C++

Teoría.

Una pila es una estructura de datos homogénea (elementos del mismo tipo), secuencial y de tamaño variable. Sólo es

posible un modo de acceso a esta estructura: a través de la cabeza de la pila. De este modo podemos añadir un elemento a

la cabeza de la pila o extraer un elemento de la cabeza de la pila. Debido a que las operaciones de extracción e inserción se

realizan por el mismo extremo, el último elemento en ser añadido será el primero en ser extraído; por ello a estas estructuras

se las conoce con el nombre de LIFO (last-in, first-out; último en entrar, primero en salir).

C a b e z a

P i l a

I n s e r t a r E x t r a e r

Otras operaciones posibles sobre la pila son la creación de una pila vacía, la interrogación de la misma para determinar si

contiene o no algún elemento y la destrucción de la pila.

Para implementar una pila como una estructura dinámica de datos se usa una lista enlazada, las operaciones de extracción e

inserción en la lista (pila) se hacen siempre sobre la cabeza de la misma.



#ifndef _MPila_h_

#define _MPila_h_

#include "MCadena.h"

namespace MPila

{

using namespace MCadena;

typedef struct TNodo *TPila;

struct TNodo

{

TCadena val;

TPila sig;

};

typedef enum { NoError, ErrorPilaLLena,

ErrorPilaVacia} TError;

TPila CrearPila();

void DestruirPila(TPila &p);

void MeterPila(TPila &p, TCadena x, TError &error);

void SacarPila(TPila &p, TCadena &x, TError &error);

bool PilaLlena(TPila p);

bool PilaVacia(TPila p);

}

Laboratorio de Programación 1ºA E.T.S.I. Informática Gestión

José Luis Pastrana Brincones @ 2005

hola

tedejo el siguiente link de un manual de programacion en lenguage c dentro de el se explica que es unapila y se incluyen varios ejemplos espero te sirva

estan por la pagina 46 a la 50 mas o menos



http://www.cvc.uab.es/shared/teach/a21292/pdf/arrays.pdf