EJERCICIOS PROPUESTOS:

PILAS Y COLAS

PROBLEMAS RESUELTOS

1)
typedef int TipoDato;

/* archivo pilaarray.h */

#include <stdio.h>
#include <stdlib.h>
#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(Pila P);
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;

1
 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;
}

2.)
Typedef char TipoDato
#include <pilaarray.cpp>

void main()
{
Pila P;
int x;

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

3.)
#include <stdio.h>
#include <stdlib.h>

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);
3
}

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;
}

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

VaciaP(&Paux);
4
 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);
}
}

5)
TipoDato MayorPila(Pila *P)
{
TipoDato Mayor,e;

Mayor = -32767;
while (! EsVaciaP(P))
{
e=PrimeroP(P);
BorrarP(&P);
if (Mayor < e)
Mayor = e;
}
return Mayor;
}

TipoDato MenorPila(Pila *P)

5
{
TipoDato Menor,e;

Menor = 32767;
while (! EsVaciaP(P))
{
e=PrimeroP(P);
BorrarP(&P);
if (Menor > e)
Menor = e;
}
return Menor;
}

float MediaPila(Pila*P)
{
TipoDato Total=0,e,k=0;

while (! EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
Total+ = e;
k++;
}
if ( k == 0 )
return 0;
else
return ( (float)Total / k);
}

6)
void LiberarPila(Pila**P)
{
while (!EsVaciaP(*P))
BorrarP(P);
}

int SonIgualesPilas(Pila *P, Pila* P1)

{
int sw = 1;
TipoDato e,e1;

while (! EsVaciaP(P) && !EsVaciaP(P1) && sw)

{
e = PrimeroP(P);
BorrarP(&P);
e1 = PrimeroP(P1);
BorrarP(&P1);
sw = (e == e1);
}
return (sw && EsVaciaP(P)&& EsVaciaP(P1));
}

19.7

void DaVueltaPila (Pila *P,Pila**Pcop)

6
{
TipoDato e;

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

int SonIgualesPilas(Pila *P, Pila* P1)

{
int sw = 1;

TipoDato e, e1;
while (! EsVaciaP(P) && !EsVaciaP(P1) && sw)
{
e = PrimeroP( P );
BorrarP( &P );
e1 = PrimeroP( P1 );
BorrarP( &P1 );
sw=(e == e1);
}
return (sw && EsVaciaP(P)&& EsVaciaP(P1));
}

int palindroma()
{
Pila *P, *Pcop;
char ch;
puts(" frase a comprobar que es palindroma");
VaciaP( &P );
for( ;(ch = getchar()) != '\n'; )
AnadeP(&P, ch);
DaVueltaPila(P, &Pcop);
return (SonIgualesPilas(P,Pcop));
}

8)
int extrana()
{
Pila *P, *P1,*Pcop;
char ch;

puts(" frase a comprobar que es extraña");

VaciaP(&P);
for( ;(ch = getchar()) != '&'; )
AnadeP(&P, ch);
VaciaP(&P1);
for( ;(ch = getchar()) != '\n'; )
AnadeP(&P1, ch);
DaVueltaPila(P, &Pcop);
return (SonIgualesPilas(P1, Pcop));
}

7
9)
int equilibrio()
{
Pila *P;
char ch,e,sw=1 ;

puts(" frase a comprobar equilibrio de parentesis");

VaciaP(&P);
for( ;(ch = getchar()) != '\n' && sw; )
if ((ch == '(') || (ch == '['))
AnadeP(&P, ch);
else
if ((ch == ')') || (ch == ']'))
if( ! EsVaciaP(P))
{
e = PrimeroP( P );
BorrarP( &P );
sw = e==ch;
}
else
sw = 0;
if ( sw )
sw = EsVaciaP(P);
return (sw);
}

10)
#include <stdio.h>
#include <stdlib.h>
#define MaxTamC 100
typedef int TipoDato;
typedef struct
{
int frente, final;
TipoDato A[MaxTamC];
}Cola;

void VaciaC(Cola* C);

void AnadeC(Cola* C,TipoDato e);
void BorrarC(Cola* C);
TipoDato PrimeroC(Cola C);
int EsVaciaC(Cola C);
int EstallenaC(Cola C);

void VaciaC(Cola* C)
{
C->frente = 0;
C->final = 0;
}

void AnadeC(Cola* C, TipoDato e)

{
if (EstallenaC( *C ))
{
puts("desbordamiento cola");
exit (1);

8
 }
C->final = (C->final + 1) % MaxTamC;
C->A[C->final] = e;
}

TipoDato PrimeroC(Cola C)
{
if (EsVaciaC(C))
{
puts("Elemento frente de una cola vacía");
exit (1);
}
return (C.A[(C.frente+1) % MaxTamC]);
}

int EsVaciaC(Cola C)
{
return (C.frente == C.final);
}

int EstallenaC(Cola C)
{
return (C.frente == (C.final+1) % MaxTamC);
}

void BorrarC(Cola* C)
{
if (EsVaciaC(*C))
{
puts("Eliminación de una cola vacía");
exit (1);
}
C->frente = (C->frente + 1) % MaxTamC;
}

11).

void GeneraColaAleatoriamente(Cola *C)

#define Max 20
{
int k;
VaciaC(C);
randomize();
for(k = random(Max); k;)
{
AnadeC(C, k);
k = random( Max );
}
}

void EscribeCola(Cola C)
{
TipoDato el;
int k = 0;

printf("\n\n");
while ( ! EsVaciaC(C))

9
 {
el = PrimeroC(C);
BorrarC( &C );
if (!(k % 10))
printf("\n");
printf("%3d", el);
k++;
}
printf("\n\n");
}

int NumeroDeElementosCola(Cola C)
{
int k = 0;

while (!EsVaciaC(C))
{
k++;
BorrarC(&C);
}
return k;
}

void EliminaMayores(Cola *C, TipoDato e)

{
TipoDato el;
Cola C1;

VaciaC(&C1);
while (!EsVaciaC(*C))
{
el = PrimeroC(*C);
BorrarC(C);
if (el <= e)
AnadeC( &C1, el);
}
*C = C1;
}

12)

#include <stdio.h>
#include <stdlib.h>
typedef int TipoDato;
struct Nodo
{
TipoDato el;
struct Nodo* sig;
};

typedef struct
{
Nodo * Frente;
Nodo * Final;
}Cola;

void VaciaC(Cola* C);

10
void AnadeC(Cola* C,TipoDato el);
void EliminarC(Cola* C);
void BorrarC(Cola* C);
TipoDato PrimeroC(Cola C);
int EsVaciaC(Cola C);
Nodo* crearnodo(TipoDato el);

void VaciaC(Cola* C)
{
C->Frente =NULL;
C->Final = NULL;
}

Nodo* crearnodo(TipoDato el)

{
Nodo* nn;

nn = (Nodo*)malloc(sizeof(Nodo));
nn->el = el;
nn->sig = NULL;
return nn;
}

int EsVaciaC(Cola C)
{
return (C.Frente == NULL);
}

void AnadeC(Cola* C,TipoDato el)

{
Nodo* a;
a = crearnodo(el);
if (EsVaciaC(*C))
C->Frente = a;
else
C->Final->sig = a;
C->Final = a;
}

void BorrarC(Cola* C)
{
Nodo *a;

if (!EsVaciaC(*C))
{
a = C->Frente;
C->Frente = C->Frente->sig;
if(C->Frente == NULL)
C->Final == NULL;
free(a);
}
else
{
puts("Error eliminación de una cola vacía");
exit(-1);
}
}

11
TipoDato PrimeroC(Cola C)
{
if (EsVaciaC(C))
{
puts("Error: cola vacía");
exit(-1);
}
return (C.Frente->el);
}

void EliminaC(Cola* C)
{
for (; C->Frente;)
{
Nodo* n;

n = C->Frente;
C->Frente = C->Frente->sig;
free(n);
}
}

13)

int SonIgualescolas(Cola *C, Cola* C1)

{
int sw=1;
TipoDato e,e1;

while (!EsVaciaC(C)&& !EsVaciaC(C1)&& sw)

{
e = PrimeroC(C);
BorrarC(&C);
e1 = PrimeroC(C1);
BorrarP(&C1);
sw =( e == e1);
}
return (sw && EsVaciaC(C)&& EsVaciaC(C1));
}

14).

void Mayormenor(Cola *C, TipoDato * Mayor, TipoDato *menor)

{
TipoDato M,m,e;

M =-32767;
m = 32767;
while(!EsVaciaC(*C))
{
e=PrimeroC(*C);
BorrarC(C);
if(M<e)
M=e;
if(m>e)
m=e;
}

12
 *Mayor=M;

*menor=m;
}

13