Programación en lenguaje C de calculadora de polinomio disperso de una variable
lista de estructuras typedef
{
int c; //El número de términos del polinomio
int e; //Índice polinómico
Lista de estructuras * siguiente//siguiente nodo
};
lista de estructuras typedef * lista enlazada;
typedef estructura Lista de nodos;
La siguiente es la declaración de función relacionada con la operación de la tabla lineal, correspondiente al archivo ListOper.h:
// Archivo: ListOper.h
#ifndef estructura de datos
#Definir estructura de datos
#Contiene " datastruct.h "
#endif
/ /Algunas declaraciones de funciones
Lista de creación booleana (lista vinculada y ampl);
Nodo *CreateNode(int e, int c);
Lista libre no válida ( lista enlazada y ampl);
Lista ordenada vacía (lista enlazada y ampl);
void eliminar nextnode(Nodo * d);
void SweepNextNode(Nodo * s);
void OutPutList(linked list & ampl);
Para implementar funciones relacionadas, el archivo correspondiente ListOper.cpp:
//Archivo: ListOper.cpp
# include & ltstdlib.h & gt
# include & ltiostream & gt
#estructura de datos ifndef
# Definir estructura de datos
#Include" datastruct.h "
#endif
#Contains " ListOper.h "
Usar espacio de nombres std
Booleano para crear una lista (lista enlazada y ampl)
{
//TODO: Crear una lista enlazada lineal
Nodo * cabeza;
cabeza = (Nodo *)malloc (tamaño de (Nodo));
if(cabeza==NULL)
{
cout & lt& lt"Error de asignación de memoria"
Devuelve falso
}
head->; next = NULL
cabeza->; c = 0;
cabeza->; e = 0;
l = encabezado
Devuelve verdadero
}
Nodo *CreateNode(int e, int c)
{
//TODO: Crear un nodo
Posición del nodo * ;
pos=(Nodo *)malloc( tamaño de(Nodo)).
if(pos==NULL)
{
cout & lt& lt"Error de asignación de memoria"
Salir (1);
}
pos-& gt; e = e
pos-& gt; next = NULL
Posición de retorno;
}
Lista libre no válida (lista vinculada y ampliada)
{
//TODO: Libera el espacio de memoria ocupado por toda la tabla lineal.
Nodo*Posición;
Nodo*Siguiente;
pos = L;
mientras(pos!=null)
p>
{
siguiente = pos-& gt; siguiente
gratis (pos); p>
}
}
Lista ordenada vacía (lista vinculada y ampliada)
{
bool flag = true/ /¿Se requiere ordenar el logotipo?
nodo * cabeza = L-& gt; siguiente;
Nodo * posición
Nodo * último
Nodo * temperatura;
if(head-& gt; next==NULL)
{
Return;
}
while(flag)
{
flag = true
last=head;
pos = last-& gt; ;
if(último == NULL | | último-& gt; siguiente==NULL)
{
Descanso;
}
Y (¡último!= NULL &&last-> siguiente!=null)
{
flag = false
pos = último-& gt; siguiente;
if(último-& gt; e & ltpos-& gt; E) //Jajajajaja, código HTML
{
SweepNextNode(último);
flag = true
}
if(último-& gt; e = = pos->e)
{
Último->c+= pos->c;
eliminar el siguiente nodo (último);
bandera = verdadero
/* último = último-& gt; siguiente;
pos = último-& gt; = último-& gt; siguiente;
}
}
}
}
} p>
void DeleteNextNode(Nodo *d)
{
Nodo *temp;
temp = d-& gt; p> p>
d->next = temp->next;
Gratis (temporal);
}
void SweepNextNode( Número de nodos)
//Es un poco vago, solo intercambia valores y no modifica punteros.
{
int c, e
c = s-& gt; p>s->c = s->siguiente->c;s->e = s->siguiente->e
s ->Siguiente->c = cs->Siguiente->e = e
}
void OutPutList(lista vinculada y ampl)
{
Nodo * posición;
pos = L-& gt; siguiente;
cout & lt& lt" expresión de salida: ";
mientras(pos!=null)
{
if(pos-& gt;c & gt0)
{
cout & lt& lt"+";
}
if(pos-& gt;c!=1)
{
cout & lt& ltpos-& gt;c ;
}
if(pos-& gt;e!=0)
{
cout & lt& lt《x^ 》;
cout & lt& ltpos-& gt;e;
}
pos = pos-& gt; }
cout & lt& ltendl
}
Archivo de unidad principal main.cpp:
# include & ltiostream & gt
# include & ltstdlib.h & gt
# include & ltctype.h & gt
#Include " ListOper.h "
Usar espacio de nombres std
LinkList AnayString(char aString[], int length);
int main(int argc , char *argv[]) // -
{
Lista enlazada L;
Comando de carácter [1024]
int len
cout & lt& lt"Polinomio disperso de una variable calculadora"< & ltendl
cout & lt& lt"Copyright @1999-2004, Liu."& lt& ltendl
cout & lt& lt【Autor: Liu Xiaoming】< & ltendl & lt& ltendl
cout & lt& ltIngrese un polinomio disperso con un máximo de 1024 caracteres:;
CIN & gt ;& gtInStr
len = strlen(InStr);
L=AnayString(InStr, len);
ordenar lista(L);
lista de salida(L);
FreeList( L);
System("pause");
Devuelve 0;
}
Cadena de análisis de tabla vinculada (char aString[ ], int length)//-
//TODO: Función de análisis de cadenas
{
Lista enlazada L = vacía
Nodo * pos = NULL
Nodo * último
Nodo *cabeza;
Crear lista (L);
cabeza = L;
Último = encabezado
int c = 0
int e;
= 0;
char temp[1];
char tp
bool plus = true
char status = "n"; //Indicador de estado, omití el caso en el que el coeficiente es negativo.
/*
n: Estado no operativo
c: Coeficiente de cálculo.
e: Calcula el índice.
p:El índice es 0.
f: Inversión finalizada en un proyecto.
*/
for(int I = 0;i<length;i++)
{
temp[0]= cadena[I ];
TP = temp[0];
Cambiar (estado)
{
Caso "n":
{
c = 0; e = 0
estado = ' c
if(tp=='-')
{
Signo más = false
Continuar;
}
if(isdigit(tp))
{
c = atoi(temp);
Continuar;
}
Si(tp= ='x ')//El polinomio comienza con x.
{
c = 1;
status = ' e
Continuar;
}
}
Caso "c":
{
if(es dígito(cadena[I]))
{
Si (signo más)
{
c = c * 1atoi(temp);
}
Otros
{
c = c * 10-atoi(temp);
}
Continuar; p>
}
si(tp=='x ')
{
si (c==0)
{
c = 1;
}
estado = ' e
e = 0;
Continuar;
}
//Aquí se considera la posibilidad de que aparezcan términos constantes en otras posiciones.
if(tp=='+')
{
más = verdadero
status = ' p
Continuar;
}
if(tp=='-')
{
Signo más = falso
status = ' p
Continuar;
}
/*if(temp[0]=='^')
{
status = ' e
e = 0;
Continuar;
} *///Esta situación puede No sucederá.
Continuar;
}//Coeficiente analítico
Caso "e":
{
if( tp=='^')
{
Continuar;
}
if(isdigit(tp))
{
e = e * 1atoi(temp);
Continuar;
}
if(tp= ='+')
{
más = verdadero
status = ' f
Continuar;
}
if(tp=='-')
{
Signo más = false
status = ' f
Continuar;
}
}//coeficiente analítico
Caso "p":
{
e = 0;
status = ' f
Continuar;
}
Caso "f":
{
pos=CreateNode(e,c);
Último -> siguiente = pos
último = pos
c = 0; e = 0;
estado = ' c
I-;
Continuar;
}< / p>
}
}
pos=CreateNode(e, c);
Finalmente -> siguiente = pos
Regresar L;
No sé si esto es lo que necesitas.