Programación en lenguaje St o
Descripción del problema:
Por ejemplo: p+q * r, la expresión solo necesita contener tres símbolos lógicos: o , NO y y.
Análisis:
/*Este programa admite cualquier expresión lógica de entrada y puede realizar operaciones AND, NOT e implicaciones. Estas expresiones pueden estar entre paréntesis. La definición e implementación de árboles binarios y pilas bintree.h y pila CPP */
# include & ltstdio.h & gt
# include & ltmalloc.h & gt
#define MAXNUM 100 El número máximo de elementos en la pila
#define MAXEXP 30 El número máximo de caracteres permitidos para que el usuario ingrese una expresión.
#Contiene "bintree.h"
#Contiene " stack.cpp "
const char y = '& amp', o = '| then = '-';
Booleano no ingresado (carácter c)
{
return(c = = ' & amp; | | c = = ' | ' | c = = '-' | | c = = ' # ');
}
boolIsNum(char c)
{
return(c & gt;= ' 0 ' & amp&c & lt= '9');
}
Valor booleano IsAlp(carácter c)
{
return((c & lt;= ' z ' & amp& ampc & gt= ' a ')| |(c & gt;= ' A ' & amp& ampc & lt = ' Z '));
}
Sintaxis de verificación booleana (char* exp)
{
char * cp = exp
mientras (*cp!= '\0')
{
if (!(IsNum(* CP)| | IsAlp(* CP) | | InOpt(* CP)| | * CP = = '(' | | * CP = = ')'))
Devuelve FALSO
cp++;
}
if (*( - cp)!= '#')
Devuelve FALSO
Devuelve VERDADERO
}< / p>
Árbol de transferencia PBinTree (char *exp)
{
pbintrenode PBT = CrtBinTree();
Pila & ltBinTreeNode * & gtST; /p>
pila<char>sc;
char* ch = exp, c;
presiona (' # ');
Y (!(sc.
GetTop()= = ' # ' & amp; & amp*ch == '# '))
{
if (IsAlp(*ch))
{
pbintrenode t = CrtBinTree();
t->; datos = * ch
St.Tweet(t);
}
si no (IsNum(*ch))
{
mientras (IsNum(*ch))
{
ch++;
}
ch-;
pbintrenode t = CrtBinTree();
t - >;data = * ch
Shengtui(t);
}
Otros
{
Cambiar(*ch)
{
Caso '(':
Empujar(*ch);
Romper;
p>Caso ")":
{
c = sc. pop();
Y (c! = '(')
{
pbintrenode t = CrtBinTree();
t ->; datos = c;
t->; rChild = ST .
st push(t);
c = sc pop();
}
Romper;
}
Valor predeterminado:
{
Y (sc. GetTop()!= ' # ' & amp& amp es GetTop()!= '(')
{
pbintrenode t = CrtBinTree();
c = sc pop()
t->; ;
t->; rChild = ST . Pop();
t->; l niño = ST . ( t);
}
if (*ch!= '#')
Empujar (* ch);
Romper ;
}
}
}
Si (! es decir, IsEmpty()&&*ch!= '# ')
ch++;
}
PBT = ST Pop();
Devolver pbt
}
void GetVariable(PBinTree pbt)
{
PBinTree vpt = pbt
if((PBT-& gt;data& gt= ' a ' && ampPBT->datos<= 'z ')|(PBT->datos>= 'A' &&PBT->datos<= 'Z '))
{
Imprimir ("Ingrese el valor de %c (1 o 0):\n ", VPT-> data
scanf ( "%c", &&VPT->data);
getchar();
}
if(VPT->child.
=null)
obtener variable(VPT->l niño);
if(VPT->l niño!=null)
obtener variable ( VPT->rChild);
}
cálculo de caracteres (PBinTree pbt)
{
PBinTree vpt = pbt
if (vpt == NULL)
{
Printf("¡No se puede evaluar ninguna expresión!");
Devuelve FALSO
}
if(VPT-& gt;LChild == NULL) encuentra nodos hoja.
Devolver VPT->datos;
if(InOpt(VPT->datos);& cálculo(VPT->l hijo)&& amp cálculo(VPT- >rChild))
{
cambiar(VPT->datos)
{
Caso y:
if(calcular(VPT->lChild)='1'&&calcular(VPT->rChild)=='1')
VPT->datos = '1'
else VPT->data="0"
Pausa;
Caso o:
if (calcular (VPT->lChild) = ' 0 ' &&calcular(VPT->rChild) == '0 ')
VPT- >data="0"
else vpt->data=" 1"
romper
caso entonces:
if(calcular(VPT->lChild) = ' 1 ' && calcular(VPT->rChild) == '0 ')
VPT->datos = "0";
else VPT->datos = ' 1 ';
Pausa;
}
}
Devolver VPT->data;
}
void main()
{
char * exp =(char *)malloc(sizeof(char)* MAXEXP);
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
Printf(" **Calculadora de expresiones lógicas 1.10 * * \n ");
printf("**Creado por Yang Pengfei (pkusocold @ Gmail)* * \n ");
printf (" * * Sólo o(|)y(&;), no (! ) y operaciones de implicación (-) * * \ n ");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \ n ");
printf(" \ n ");
Printf("Ingrese la expresión lógica a calcular (debe agregar un \" # \ " después de la expresión):\ n ");
gets (exp);
And (!CheckSyntax(exp))
{
Printf("Error de entrada de expresión, vuelva a ingresar:\n" ) ;
gets(exp);
}
pbint REE PBT = transferir árbol(exp);
obtener variable(PBT ) ;
Printf("El valor de esta expresión lógica es: %c \n ", Caculate(PBT));
}