C/Visual C - necesito ayuda urgente

 
Vista:

necesito ayuda urgente

Publicado por ayudaa !!!! (1 intervención) el 27/09/2001 21:55:48
necesito ayuda sobre un programa que reciba un polinomio y lo reduzca a su minima expresion
es decir que sume los sumando s ocn el mismo exponente
utilizando nodos
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Programa para reducir un polinomio a su mínima expresión usando nodos

Publicado por Alejandro (913 intervenciones) el 16/10/2024 00:00:24
A continuación, te presento un ejemplo de un programa en C que utiliza una lista enlazada para representar un polinomio y reduce el polinomio a su mínima expresión sumando los términos con el mismo exponente.

Código del programa



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <stdio.h>
#include <stdlib.h>
 
typedef struct Nodo {
    int coeficiente; // Coeficiente del término
    int exponente;   // Exponente del término
    struct Nodo* siguiente; // Puntero al siguiente nodo
} Nodo;
 
// Función para crear un nuevo nodo
Nodo* crear_nodo(int coeficiente, int exponente) {
    Nodo* nuevo_nodo = (Nodo*)malloc(sizeof(Nodo));
    nuevo_nodo->coeficiente = coeficiente;
    nuevo_nodo->exponente = exponente;
    nuevo_nodo->siguiente = NULL;
    return nuevo_nodo;
}
 
// Función para insertar un término en la lista
void insertar_termino(Nodo** cabeza, int coeficiente, int exponente) {
    Nodo* nuevo_nodo = crear_nodo(coeficiente, exponente);
    if (*cabeza == NULL) {
        *cabeza = nuevo_nodo;
    } else {
        Nodo* actual = *cabeza;
        Nodo* anterior = NULL;
 
        // Insertar en orden decreciente de exponentes
        while (actual != NULL && actual->exponente > exponente) {
            anterior = actual;
            actual = actual->siguiente;
        }
 
        // Si el exponente ya existe, sumar los coeficientes
        if (actual != NULL && actual->exponente == exponente) {
            actual->coeficiente += coeficiente;
            free(nuevo_nodo); // Liberar el nodo si se suma
        } else {
            nuevo_nodo->siguiente = actual;
            if (anterior == NULL) {
                *cabeza = nuevo_nodo; // Insertar al inicio
            } else {
                anterior->siguiente = nuevo_nodo; // Insertar en medio
            }
        }
    }
}
 
// Función para imprimir el polinomio
void imprimir_polinomio(Nodo* cabeza) {
    Nodo* actual = cabeza;
    while (actual != NULL) {
        printf("%dx^%d", actual->coeficiente, actual->exponente);
        if (actual->siguiente != NULL) {
            printf(" + ");
        }
        actual = actual->siguiente;
    }
    printf("\n");
}
 
// Función para liberar la memoria de la lista
void liberar_lista(Nodo* cabeza) {
    Nodo* actual = cabeza;
    while (actual != NULL) {
        Nodo* siguiente = actual->siguiente;
        free(actual);
        actual = siguiente;
    }
}
 
int main() {
    Nodo* polinomio = NULL;
    int coeficiente, exponente;
    char continuar;
 
    do {
        printf("Ingrese el coeficiente: ");
        scanf("%d", &coeficiente);
        printf("Ingrese el exponente: ");
        scanf("%d", &exponente);
        insertar_termino(&polinomio, coeficiente, exponente);
 
        printf("¿Desea agregar otro término? (s/n): ");
        scanf(" %c", &continuar);
    } while (continuar == 's' || continuar == 'S');
 
    printf("El polinomio reducido es: ");
    imprimir_polinomio(polinomio);
 
    liberar_lista(polinomio);
    return 0;
}

Explicación del código



1. Estructura del nodo:
- Cada nodo contiene un coeficiente, un exponente y un puntero al siguiente nodo.

2. Funciones:
- `crear_nodo()`: Crea un nuevo nodo con el coeficiente y el exponente dados.
- `insertar_termino()`: Inserta un término en la lista enlazada. Si el exponente ya existe, suma los coeficientes.
- `imprimir_polinomio()`: Imprime el polinomio en su forma reducida.
- `liberar_lista()`: Libera la memoria ocupada por la lista enlazada.

3. Función principal:
- Permite al usuario ingresar términos del polinomio y los inserta en la lista.
- Imprime el polinomio reducido al final.

Consideraciones




- Asegúrate de compilar el programa en un entorno que soporte C, como Turbo C o cualquier compilador moderno.
- Puedes mejorar el manejo de errores y la validación de entradas según sea necesario.

¡Saludos!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar