Escolar Documentos
Profissional Documentos
Cultura Documentos
PILAS Y COLAS
PROBLEMAS RESUELTOS
19.1.
/* archivo pilaarray.h */
#include <stdio.h>
#include <stdlib.h>
#define MaxTamaPila 100
typedef struct
{
TipoDato A[MaxTamaPila];
int cima;
}Pila;
void VaciaP(Pila* P)
{
P -> cima = -1;
}
1
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.
void main()
{
Pila P;
int x;
VaciaP(&P);
2
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 <stdio.h>
#include <stdlib.h>
void VaciaP(Pila** P)
{
*P = NULL;
}
3
Nodo * nn;
nn = NuevoNodo(elemento);
nn->sig = (*P);
*P = 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;
}
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);
}
4
{
return P == NULL;
}
19.4.
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);
}
}
VaciaP(Pcop);
while (!EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
AnadeP(Pcop,e);
}
}
while (! EsVaciaP(P))
{
e = PrimeroP(P);
BorrarP(&P);
printf("%d\n", e);
}
}
19.5..
5
{
TipoDato Mayor,e;
Mayor = -32767;
while (! EsVaciaP(P))
{
e=PrimeroP(P);
BorrarP(&P);
if (Mayor < e)
Mayor = e;
}
return Mayor;
}
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);
}
19.6.
void LiberarPila(Pila**P)
{
while (!EsVaciaP(*P))
BorrarP(P);
}
6
{
int sw = 1;
TipoDato e,e1;
19.7
VaciaP( Pcop );
while (! EsVaciaP( P ))
{
e = PrimeroP( P );
BorrarP( &P );
AnadeP(Pcop, e);
}
}
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));
7
}
19.9.
int extrana()
{
Pila *P, *P1,*Pcop;
char ch;
19.10.
int equilibrio()
{
Pila *P;
char ch,e,sw=1 ;
19.11.
#include <stdio.h>
#include <stdlib.h>
#define MaxTamC 100
typedef int TipoDato;
typedef struct
{
8
int frente, final;
TipoDato A[MaxTamC];
}Cola;
void VaciaC(Cola* C)
{
C->frente = 0;
C->final = 0;
}
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;
9
}
19.12.
void EscribeCola(Cola C)
{
TipoDato el;
int k = 0;
printf("\n\n");
while ( ! EsVaciaC(C))
{
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;
}
VaciaC(&C1);
while (!EsVaciaC(*C))
{
10
el = PrimeroC(*C);
BorrarC(C);
if (el <= e)
AnadeC( &C1, el);
}
*C = C1;
}
19.13.
#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)
{
C->Frente =NULL;
C->Final = NULL;
}
nn = (Nodo*)malloc(sizeof(Nodo));
nn->el = el;
nn->sig = NULL;
return nn;
}
int EsVaciaC(Cola C)
{
return (C.Frente == NULL);
}
11
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);
}
}
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);
}
}
19.14
12
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));
}
19.16.
M =-32767;
m = 32767;
while(!EsVaciaC(*C))
{
e=PrimeroC(*C);
BorrarC(C);
if(M<e)
M=e;
if(m>e)
m=e;
}
*Mayor=M;
*menor=m;
}
13