Java - Ayuda con este problema

   
Vista:

Ayuda con este problema

Publicado por Steven (1 intervención) el 22/09/2015 19:29:13
Ayuda con este problema :
Considere una clase Polinomio que almacene un polinomio de la forma
p(x) = 5x10 + 9x7 – x – 10
como una lista enlazada de términos. Un término contiene el coeficiente y el exponente de x. Por ejemplo, el polinomio anterior se almacenaría como
(5,10)->(9,7)->(-1,1)->(-10,0)
a. Implemente un programa que le permita crear y añadir términos a sus polinomios, sumarlos y mostrarlos por pantalla.
Nota: En el literal a asuma que los términos de sus polinomios siempre serán añadidos en el orden correcto.
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

Ayuda con este problema

Publicado por Andrés (231 intervenciones) el 24/09/2015 00:08:07
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
package polinomios;
 
/**
 *
 * @author Andrés Mella Romero
 */
public class Main {
 
    public static void main(String[] args) {
         //Instanciamos un polinomio
        Polinomio polinomio = new Polinomio();
        //Instanciamos un término
        Termino termino = new Termino(3,2);
        //agregamso el término al polinomio
        polinomio.agregarTermino(termino);
         //Instanciamos un término
        termino = new Termino(-4,1);
        //agregamso el término al polinomio
        polinomio.agregarTermino(termino);
        //Lo imptimimos
        polinomio.imprimir();
        System.out.println();
        //Instanciamos un polinomio
        Polinomio polinomio2 = new Polinomio();
        //Instanciamos un término
        termino = new Termino(23.5,3);
         //agregamso el término al polinomio
        polinomio2.agregarTermino(termino);
        //Instanciamos un término
        termino = new Termino(-1,2);
         //agregamso el término al polinomio
        polinomio2.agregarTermino(termino);
        //Instanciamos un término
        termino = new Termino(-1,0);
         //agregamso el término al polinomio
        polinomio2.agregarTermino(termino);
        //Lo imptimimos
        polinomio2.imprimir();
        System.out.println();
        //Instanciamos a la clase que opera con polinomios
        Operaciones operaciones = new Operaciones();
        //Sumamos!
        Polinomio suma = operaciones.sumar(polinomio, polinomio2);
        //Imprimimos
        suma.imprimir();
        System.out.println();
        //Acabamos! :)
    }
 
}

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package polinomios;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
 *
 * @author Andrés Mella Romero
 */
//Clase que representa a un polinomio
public class Polinomio {
    //Inicio del Polinomio
    private Termino cabeza;
 
    //Constructor que inicializa la referencia al Polinomio
    public Polinomio() {
 
        cabeza = null;
 
    }
    //Método que obtiene el inicio del Polinomio
    public Termino getCabeza() {
        return cabeza;
    }
    //Método que verifica si en el polinomio existe un término con un exponente dado
    public boolean existeTerminoConExponente(Termino termino) {
        //Obtenemos la rerefencia al inicio del polinomio
        Termino iterador = cabeza;
        //Ciclamos por la lista
        while( null != iterador ) {
            //Compara los exponentes
            if(iterador.getExponente() == termino.getExponente()) {
                //Sí existe!
                return true;
            }
            //Siguiente elemento a iterar
            iterador = iterador.getSiguiente();
 
        }
        //No existe!
        return false;
 
    }
    //Similar al anterior, pero este regresa null ó el término
    public Termino obtenerTerminoPorExponente(Termino termino) {
        //Obtenemos la rerefencia al inicio del polinomio
        Termino iterador = this.cabeza;
        //Ciclamos por la lista
        while( null != iterador ) {
            //Compara los exponentes
            if(iterador.getExponente() == termino.getExponente()) {
                //Lo encontramos!
                return iterador;
            }
            //Siguiente elemento a iterar
            iterador = iterador.getSiguiente();
 
        }
        //No encontrado!
        return null;
 
    }
    //Obtienen el último término del Polinomio
    private Termino obtenerUltimoTermino() {
        //Obtenemos la rerefencia al inicio del polinomio
        Termino iterador = cabeza;
        //Ciclamos por la lista
        while( null != iterador && null != iterador.getSiguiente()) {
             //Siguiente elemento a iterar
            iterador = iterador.getSiguiente();
 
        }
        //Regresar el elemento
        return iterador;
    }
    //Agregar un termino al final del polinomio
    public void agregarTermino(Termino termino) {
        //Obtenemos el último término del polinomio
        Termino ultimoTermino = obtenerUltimoTermino();
        //Si no hay último término, agregamos como inicio
        if(null == ultimoTermino) {
            cabeza= termino;
        }else {
            //Establecer como siguiente elemento
            ultimoTermino.setSiguiente(termino);
        }
 
    }
    //Imprimir el polionomio
    public void imprimir() {
         //Obtenemos la rerefencia al inicio del polinomio
        Termino iterador = cabeza;
        //Una lista para ordenar los elmentos
        List<Termino> terminos = new ArrayList<Termino>();
        //Ciclamos por el polinomio
        while( null != iterador) {
           //Agregamos a la lista
           terminos.add(iterador);
           //Siguiente elemento a iterar
           iterador= iterador.getSiguiente();
        }
        //Ordenamos
        Collections.sort(terminos);
        //Imprimir!
        for(Termino termino : terminos){
            System.out.print(termino.toString()+" ");
        }
 
    }
 
}

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
package polinomios;
/**
 *
 * @author Andrés Mella Romero
 */
//Clase que representa un término
public class Termino implements Comparable<Termino> {
 
    //El coeficiente del término
    private double coeficiente;
    //El exponente del término
    private int exponente;
    //La referencia al siguiente término
    private Termino siguiente;
 
    //Constructor que recibe sólo el coeficiente
    public Termino(double coeficiente) {
        //su exponente en cero
        this(coeficiente, 0);
    }
 
    //Constructor que recibe el coeficiente y el exponente
    public Termino(double coeficiente, int exponente) {
        this.coeficiente = coeficiente;
        this.exponente = exponente;
        this.siguiente = null;
    }
    //Método para establecer el coeficiente
    public double getCoeficiente() {
        return coeficiente;
    }
    //Método para obtener el coeficiente
    public void setCoeficiente(double coeficiente) {
        this.coeficiente = coeficiente;
    }
    //Método para obtener el exponente
    public int getExponente() {
        return exponente;
    }
    //Método para establecer el exponente   
    public void setExponente(int exponente) {
        this.exponente = exponente;
    }
    //Método para obtener la referenccia al siguiente término
    public Termino getSiguiente() {
        return siguiente;
    }
    //Método para establecer la referenccia al siguiente término
    public void setSiguiente(Termino siguiente) {
        this.siguiente = siguiente;
    }
    //Imprimir un término
    @Override
    public String toString() {
 
        StringBuilder sb = new StringBuilder();
        if (0d != coeficiente) {
            if (coeficiente > 0) {
                sb.append("+");
            }
            sb.append(coeficiente);
            switch (exponente) {
                case 0:
                    break;
                case 1:
                    sb.append("x");
                    break;
                default:
                    sb.append("x^");
                    sb.append(exponente);
 
            }
 
        }
 
        return sb.toString();
    }
    //Para ordenar el polinomio según sus exponentes
    @Override
    public int compareTo(Termino o) {
        if (o.getExponente() == this.exponente) {
            return 0;
        } else if (o.getExponente() > this.exponente) {
            return 1;
        } else {
            return -1;
        }
    }
 
}

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
package polinomios;
/**
 *
 * @author Andrés Mella Romero
 */
//Clase que opera con Polinomios
public class Operaciones {
    //Método que suma dos polinomios
    public Polinomio sumar(Polinomio polinomio1, Polinomio polinomio2) {
        //Polinomio que contiene la suma       
        Polinomio suma = new Polinomio();
        //necesitamos que sean los mismos exponentes para sumar coeficientes!
 
        //Obtenemos la rerefencia al inicio del polinomio
        Termino iterador = polinomio1.getCabeza();
        //Ciclamos por el polinomio
        while( null != iterador ) {
           //Encontramos el término en el otro polinomio que tenga el mismo coeficiente
           Termino termino = polinomio2.obtenerTerminoPorExponente(iterador);
           //Sí lo encontramos, enconces, sumar ambos términos
           if( null != termino) {
            Termino sumando = new Termino(iterador.getCoeficiente()+termino.getCoeficiente(), termino.getExponente());
            suma.agregarTermino(sumando);
           }else {
               //Sí no lo encontramos, enconces, agregar a la suma
            suma.agregarTermino(new Termino(iterador.getCoeficiente(), iterador.getExponente()));
           }
           //Siguiente elemento a iterar
           iterador = iterador.getSiguiente();
        }
        //Ahora verifcar todos aquellos términos que no se encuantran en el polinomio 1
        //Obtenemos la rerefencia al inicio del polinomio
        iterador = polinomio2.getCabeza();
         //Ciclamos por el polinomio
        while( null != iterador ) {
            //Si no existe, simplemente agregar a la suma
            if(!polinomio1.existeTerminoConExponente(iterador)) {
 
                suma.agregarTermino(new Termino(iterador.getCoeficiente(), iterador.getExponente()));
 
            }
           //Siguiente elemento a iterar
            iterador = iterador.getSiguiente();
 
        }
        //Regresar la suma
        return suma;
 
    }
 
}


Untitled
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