PolinoMios

//
//  main.c
//  Suma de Polinomios
//
//  Created by Joaquin on 31/3/15.
//  Copyright (c) 2015 Joaquin Gimenez. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>


typedef struct nodo poli_t;

typedef struct nodo {
    int expon;
    int coef;
    poli_t *sgte;
} poli_t;

void addNode(poli_t **, poli_t *);
void printPol(poli_t *, char);
poli_t *sumaPoli(poli_t *, poli_t *);



int main(int argc, const char * argv[]) {
    poli_t *a = NULL, *b = NULL, *c=NULL;
    poli_t *tmp = NULL;
    int op, co, ex;

    do {
        printf("\nMenu \n1)Agregar un elemento al polinomio A \n2)Agregar un elemento al pelinomio a B \n3)Imprimir polinomios \n4)Sumar e imprimir polinomios \nOpcion: ");
        scanf("%d", &op);
        switch (op) {
            case 1:
                printf("\nPolinomio A: Agregar coeficiente -> ");
                scanf("%d",&co);

                printf("Polinomio A: Agregar exponente -> ");
                scanf("%d", &ex);

                tmp= (poli_t *) malloc(sizeof(struct nodo));
                if (tmp) {
                    tmp->expon = ex;
                    tmp->coef = co;
                    tmp->sgte = NULL;
                } else{
                    printf("ERROR, no se ha podido asignar a la memoria.");
                }
                addNode(&a , tmp);
                printPol(a, 'a');
                break;
            case 2:
                printf("\nPolinomio B: Agregar coeficiente -> ");
                scanf("%d",&co);

                printf("Polinomio B: Agregar exponente -> ");
                scanf("%d", &ex);

                tmp= (poli_t *) malloc(sizeof(struct nodo));
                if (tmp) {
                    tmp->expon = ex;
                    tmp->coef = co;
                    tmp->sgte = NULL;
                } else{
                    printf("ERROR, no se ha podido asignar a la memoria.");
                }
                addNode(&b , tmp);
                printPol(b, 'b');
                break;

            case 3:
                printPol(a, 'a');
                printPol(b, 'b');
                printPol(c, 'c');
                break;
            case 4:
                printf("Suma de pol: ");
                c=sumaPoli(a,b);
                printPol(c, 'c');
                break;
            case 0:
                break;
            default:
                printf("Error. Opcion %d es invalida.", op);
                break;
        }
    } while (op != 0);
    return 0;
}


void addNode (poli_t ** ptr, poli_t * newNode){
    poli_t ** pp, *actual;
    pp = ptr;
    while (((actual=*pp) != NULL) && (actual->expon > newNode->expon)) {
        pp = &actual->sgte;
    }
    *pp = newNode;
    newNode->sgte = actual;
}


void printPol (poli_t *p, char x){
    if (!p) {
        printf("\nEl polinmio %c esta vacio", x);
    } else{
        printf("\nPolinomio %c -> ", x);
        while (p) {
            if (p->sgte) {
                if (p->expon == 1) {
                    printf("%d x + ", p->coef);
                } else {
                    printf("%d x^%d +",p->coef, p->expon );
                }
            } else {
                if (p->expon == 0) {
                    printf("%d ", p->coef);
                } else if (p->expon == 1) {
                    printf("%d x + ", p->coef);
                } else {
                    printf("%d x^%d +",p->coef, p->expon );
                }
            }
            p = p->sgte;
        }
    }
}

poli_t *sumaPoli (poli_t *a, poli_t *b){
    void agregar (int, int, poli_t **);
    poli_t *ultimo, *primero, *temp;
    ultimo = (poli_t *)malloc(sizeof(struct nodo));
    if (!ultimo) {
        printf("\nERROR. No se pudo asignar espacio de memoria para el polinomio c");
    } else {
        primero = ultimo;
        while (a && b) {
            if (a->expon < b->expon) {
                agregar(b->coef, b->expon, &ultimo);
                b = b->sgte;
            } else if (a->expon == b->expon) {
                agregar(a->coef + b->coef, a->expon, &ultimo);
                a = a->sgte;
                b = b->sgte;
            } else {
                agregar(a->coef, a->expon, &ultimo);
                a = a->sgte;
            }
        }
        for (; a; a=a->sgte) {
            agregar(a->coef, a->expon, &ultimo);
        }
        for (; b; b=b->sgte) {
            agregar(b->coef, b->expon, &ultimo);
        }
        ultimo->sgte = NULL;
        temp = primero;
        primero = primero->sgte;
        free(temp);
        return primero;
    }
    return NULL;
}

void agregar (int co, int ex, poli_t **q) {
    poli_t * temp;
    temp = (poli_t *)malloc(sizeof(struct nodo));
    if (!temp) {
        printf("ERROR Critico. No se ha asignado memoria en el polinomio c!");
        exit(1);
    }
    temp->coef = co;
    temp->expon = ex;
    (*q)->sgte = temp;
    *q = temp;
}