Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Unidad10 Codigof1
Unidad10 Codigof1
EJEMPLO 10.3
Paso de notación infija a notación postifija:
la expresión 2 + 4 * 3 * ( 1 + 2 ) en notación postfija es 2 4 3 * 1 2 + * +
la expresión 3 + 4 * 5 ^ ( 1 / 2 ) en notación postfija es 3 4 5 1 2 / ^ * +
la expresión 6.25 * 4 + 5.7 en notación postfija es 6.25 4 * 5.7 +
PROBLEMAS RESUELTOS
10.1.
#include <stdio.h>
#include <stdlib.h>
typedef float TipoElemento;
typedef struct UnNodo
{
TipoElemento e;
struct UnNodo *sig;
}Nodo;
typedef Nodo Pila;
void VaciaP(Pila** P)
{
*P = NULL;
}
1
2 Algoritmos y estructuras de datos. Una perspectiva en C. Libro de Problemas
}
Aux = P->e;
return Aux;
}
void BorrarP(Pila** P)
{
Pila *NuevoNodo;
if (EsVaciaP(*P))
{
puts("Se intenta sacar un elemento en pila vacía");
exit (1);
}
NuevoNodo=(*P);
(*P) = NuevoNodo->sig;
free(NuevoNodo);
}
10.2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
10.3
float valor(char c)
{
return (float) c;
}
10.4
#include <stdio.h>
#include <stdlib.h>
enum Tpalo {oros, copas, espadas, bastos};
Pilas y sus aplicaciones 5
enum Tvalor { as, dos, tres, cuatro, cinco, seis, siete, sota, caballo, rey};
struct Tcarta
{
Tpalo palo;
Tvalor valor;
} ;
typedef Tcarta TipoElemento;
typedef struct unnodo
{
TipoElemento e;
struct unnodo *sig;
}Nodo;
typedef Nodo Pila;
typedef Pila Pila_de_Cartas ;
Tcarta car;
int i;
VaciaP(maz);
printf("mazo\n");
for (i = 0; i < 40; i++)
{
LeeCarta(&car, n[i]);
EscribeCarta(car);AnadeP(maz, car);
};
printf("fin mazo\n");
}
void main(void)
Pilas y sus aplicaciones 7
{
Pila_de_Cartas *Monton,*Descartes, *mon[4];/*mazo descartes y bases*/
int FinDelSolitario, Colocada, AlgunaColocada, i;
Tcarta CartaAux; /*auxiliar para cartas*/
int Numeros_de_Cartas[40]; /*vector con cartas barajadas*/
Barajar_Las_Cartas(Numeros_de_Cartas);
for (i = 0 ; i < 4; i++) /*Pone las bases vacias */
VaciaP(&mon[i]);
LeeMazo(&Monton, Numeros_de_Cartas); /*Realiza la lectura inicial del mazo*/
FinDelSolitario = 0;
while (! FinDelSolitario)
{
VaciaP(&Descartes);
Colocada = 0;
AlgunaColocada = 0;
while (! EsVaciaP(Monton))
{ /*Pasa una pareja al montón de descartes. Si solo hay una debe pasarla*/
CartaAux=PrimeroP(Monton);
BorrarP(&Monton);
AnadeP(&Descartes, CartaAux);
if (!EsVaciaP(Monton))
{
CartaAux = PrimeroP(Monton);
BorrarP(&Monton);
AnadeP(&Descartes, CartaAux);
}
ColocaCarta(&Descartes, mon, &Colocada); /*pasa cartas a las bases*/
AlgunaColocada = AlgunaColocada || Colocada;
}
printf("\n vuelta al mazo\n"); DaVuelta(&Monton, &Descartes);
printf("\n");
FinDelSolitario = !AlgunaColocada ||EsVaciaP(Monton);
}
if (EsVaciaP(Monton))
printf(" solitario realizado\n");
else
printf(" solitario fallido\n");
}
10.5
{
EscribeListaAlReves(p->sig);
printf("%c",p->el);
}
}
10.6
elemento e, e1;
Pila *p;
VaciaP(&p);
e.n =n ; e.d = d;
e.h = h;
e.u = u;
e.estado = uno;
AnadeP(&p, e);
while (! EsVaciaP(p))
{
e = PrimeroP(p);
BorrarP(&p);
switch (e.estado)
{
case uno:
{
if (e.n == 1)
printf(" llevo disco %3d del palo %3d al palo %3d\n",e.n,e.d,e.h);
else
{
e1.n = e.n-1;
e1.estado = uno;
e1.d = e.d;
e1.h = e.u;
e1.u = e.h;
e.estado = dos;
AnadeP(&p, e);
AnadeP(&p, e1);
}
break;
}
case dos:
{
printf(" llevo disco %3d del palo %3d al palo %3d\n",e.n,e.d,e.h);
e1.n = e.n - 1;
e1.estado = uno;
e1.d = e.u;
e1.h = e.h;
e1.u = e.d;
AnadeP(&p, e1);
}
}
}
}
void main(void)
{
Hanoinr(4, 1, 2, 3);
}
10.7
#define n 5
Pilas y sus aplicaciones 11
enum Estados {Ninguno, Incluido, Excluido} ;
struct elemento
{
Estados estado;
} ;
typedef elemento TipoDato;
int Pesos[n], OabjetivoAalcanzar;
void Inicializa()
{
Pesos[0]= 7; Pesos[1] = 5; Pesos[2] = 4; Pesos[3] = 4; Pesos[4] = 1;
OabjetivoAalcanzar = 10;
}
10.8.
#define nn 8
enum Estados {uno, dos} ;
struct elemento
{
Estados Estado;
int Posibilidad;
};
typedef elemento TipoElemento;
int Contador, i, j, x, y, DespX[8],DespY[8],Tablero[8][8], n ,nCuadrado;
void Escribesolucion()
{
int i, j;
for(i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
printf("%5d",Tablero[i][j]);
printf("\n");
};
printf("solución %3d\n",Contador);
};
void ensayartodas()
{
int Posibilidad = -1;
do
{
Posibilidad++;
x += DespX[Posibilidad];
y += DespY[Posibilidad];
if ((x < n) && (y < n) && (x >= 0) && (y >= 0))
if (Tablero[x][y] == 0)
{
Tablero[x][y ] = i;
if (i < nCuadrado)
{
i ++;
ensayartodas();
i --;
}
else
{
Escribesolucion();
Contador++;
}
Tablero[x][y] = 0;
}
x -= DespX[Posibilidad];
y -= DespY[Posibilidad];
}
14 Algoritmos y estructuras de datos. Una perspectiva en C. Libro de Problemas
while(Posibilidad<8-1);
}
void ensayartodasnr()
{
int Posibilidad,colocado;
Pila *P;
elemento e, e1;
VaciaP(&P);
e.Posibilidad = -1;
e.Estado = uno;
AnadeP(&P, e);
while (! EsVaciaP(P))
{
e1=PrimeroP(P);
BorrarP(&P);
e = e1;
switch (e.Estado)
{
case uno:
{
Posibilidad = e.Posibilidad;
colocado = 0;
while (! colocado && (Posibilidad < 8-1))
{
Posibilidad++;
x += DespX[Posibilidad];
y +=DespY[Posibilidad];
if ((x < n) && (y < n) && (x >= 0) && (y >= 0))
if (Tablero[x][y] == 0)
colocado = 1;
if (! colocado)
{
x -= DespX[Posibilidad];
y -= DespY[Posibilidad];
}
}
if (colocado)
{
Tablero[x][y] = i;
if (i == nCuadrado)
{
Escribesolucion();
Contador ++;
e.Estado = dos;
e.Posibilidad = Posibilidad;
i ++;
AnadeP(&P, e);
}
else
{
e.Estado = uno;
e.Posibilidad = Posibilidad;
AnadeP(&P, e);
e.Estado = dos;
Pilas y sus aplicaciones 15
e.Posibilidad = Posibilidad;
AnadeP(&P, e);
e.Estado = uno;
e.Posibilidad = -1;
AnadeP(&P, e);
i ++;
}
}
break;
}
case dos:
{
Posibilidad = e.Posibilidad;
Tablero[x][y] = 0;
i --;
x -= DespX[Posibilidad];
y -= DespY[Posibilidad];
}
}
}
}
void main(void)
{
printf("valor de n ");
scanf("%d",&n);
nCuadrado = n * n;
DespX[0] = 2; DespY[0] = 1; DespX[1] = 1; DespY[1] = 2;
DespX[2] = -1; DespY[2] = 2; DespX[3] = -2; DespY[3] = 1;
DespX[4] = -2; DespY[4] = -1; DespX[5] = -1; DespY[5] = -2;
DespX[6] = 1; DespY[6] = -2; DespX[7] = 2; DespY[7] = -1;
Contador=1;
for (i = 0; i < n; i++)
for (j = 0;j < n; j++)
Tablero[i][j] = 0;
Tablero[0][0] = 1;
i = 2;
x = 0;
y = 0;
/*ensayartodasnr();*/
ensayartodas();
}