PILAS

Capítulo 19

PILAS Y COLAS


PROBLEMAS RESUELTOS

19.1.

typedef int TipoDato;

/* archivo pilaarray.h */

#include
#include
#define MaxTamaPila 100

typedef struct
{
TipoDato A[MaxTamaPila];
int cima;
}Pila;

void VaciaP(Pila* P);
void AnadeP(Pila* P,TipoDato elemento);
void BorrarP(Pila* P);
TipoDato PrimeroP(Pila P);
int EsVaciaP(Pila P);
int EstallenaP(PilaP);
void Pop(Pila* P, TipoDato elemento);
TipoDato Push(Pila *P);

void VaciaP(Pila* P)
{
P -> cima = -1;
}

void AnadeP(Pila* P,TipoDato elemento)
{
if (EstallenaP(*P))
{
puts("Desbordamiento pila");
exit (1);
}
P->cima++;
P->A[P->cima] = elemento;
}

void Pop(Pila* P,TipoDato elemento)
{
AnadeP(P, elemento);
}

TipoDato Push(Pila *P)
{TipoDato Aux;
if (EsVaciaP(*P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
Aux = P->A[P->cima];
P->cima--;
return Aux;
}

TipoDato PrimeroP(Pila P)
{
TipoDato Aux;
if (EsVaciaP(P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
Aux = P.A[P.cima];
return Aux;
}

void BorrarP(Pila* P)
{
if(EsVaciaP(*P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
P->cima--;
}

int EsVaciaP(Pila P)
{
return P.cima == -1;
}

int EstallenaP(Pila P)
{
return P.cima == MaxTamaPila-1;
}

19.2.

Typedef char TipoDato
#include

void main()
{
Pila P;
int x;

VaciaP(&P);
do
{
printf("dame dato -1=fin \n");scanf("%d",&x);
if (x != -1)
AnadeP(&P, x);
}
while (x != -1);
printf("escritura de la pila\n");
while(!EsVaciaP(P))
{
printf("%d \n",PrimeroP(P));
BorrarP( &P );
}
}

19.3.

#include
#include

typedef int TipoDato;
typedef struct unnodo
{
TipoDato el;
struct unnodo *sig;
}Nodo;

typedef Nodo Pila;

Nodo* NuevoNodo(TipoDato elemento);void VaciaP(Pila** P);
void AnadeP(Pila** P,TipoDato elemento);
void BorrarP(Pila** P);
TipoDato PrimeroP(Pila *P);
int EsVaciaP(Pila *P);
void Pop(Pila** P,TipoDato elemento);
TipoDato Push(Pila **P);

Nodo* NuevoNodo(TipoDato elemento)
{
Nodo *a ;
a = (Nodo*)malloc(sizeof(Nodo));
a -> el = elemento;
a -> sig = NULL;
return a;
}

void VaciaP(Pila** P)
{
*P =NULL;
}

void AnadeP(Pila** P, TipoDato elemento)
{
Nodo * nn;
nn = NuevoNodo(elemento);
nn->sig = (*P);
*P = nn;
}

void Pop(Pila** P,TipoDato elemento)
{
AnadeP(P, elemento);
}

TipoDato Push(Pila **P)
{
TipoDato Aux;
Pila *nn;

if (EsVaciaP(*P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
Aux = (*P)->el;
nn = *P;*P = nn->sig;
free(nn);
return Aux;
}

TipoDato PrimeroP(Pila *P)
{
TipoDato Aux;

if (EsVaciaP(P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
Aux = P->el;
return Aux;
}

void BorrarP(Pila** P)
{
Pila *nn;

if (EsVaciaP(*P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
nn =(*P);(*P)= nn->sig;
free(nn);
}

int EsVaciaP(Pila *P)
{
return P == NULL;
}

19.4.

void CopiaPila (Pila *P, Pila**Pcop)
{
Pila *Paux;
TipoDato e;

VaciaP(&Paux);
while (! EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
AnadeP(&Paux,e);
}
VaciaP(Pcop);
while (! EsVaciaP(Paux))
{
e = PrimeroP(Paux);
BorrarP(&Paux);AnadeP(Pcop,e);
}
}

void DaVueltaPila (Pila *P, Pila**Pcop)
{
TipoDato e;

VaciaP(Pcop);
while (!EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
AnadeP(Pcop,e);
}
}

void EscribePila(Pila *P)
{
TipoDato e;

while (! EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
printf("%d\n", e);
}
}

19.5..

TipoDato MayorPila(Pila *P)
{
TipoDato...