Ejercicios
Un polinomio se puede representar como una lista enlazada. El primer nodo de la lista representa el primer termino del polinomio, el segundo nodo al segundo término del polinomio y así sucesivamente. Cada nodo tiene como campo el dato el coeficiente del término y el exponente.
Clase Main
Clase Main
import java.util.Scanner;
public class Ejercicio7 {
public static int ingresarEntero(String mensaje, int min, int max) {
Scanner ingreso = new Scanner(System.in);
int dato;
do {
System.out.println(mensaje +" entre "+min +" y "+max);
dato = ingreso.nextInt();
} while (dato < min || dato > max);
return dato;
}
public static String ingresarString(String mensaje){
Scanner ingreso=new Scanner(System.in);
String texto="";
System.out.println(mensaje);
texto= ingreso.nextLine();
return texto;
}
public static void main(String[] args) {
int resp=0, num=0 ,grado=0,op=0;
Lista coleccion=new Lista();
Scanner Entrada= new Scanner(System.in);
do{
System.out.println("1-->Ingresar terminos \n2-->Reemplazar terminos(varios valores)\n3-->reemplazar con un valor determinado\nSeleccione una: ");
op=Entrada.nextInt();
switch(op){
case 1:{
do{
coleccion.agregarNodoAlFinal(new Numero(ingresarString("Ingrese el signo del termino \n Positivo --> +\n Negativo --> -"),
ingresarEntero("Ingrese el termino: ",1,100),
ingresarEntero("Ingrese el grado deltermino ",0,100)));
System.out.println("¿Desea ingresar un termino adicional?");
resp=Entrada.nextInt();
}while(resp!=0);
coleccion.recorreLista();
}
break;
case 2:
coleccion.reemplazo(0.5);
coleccion.reemplazo(1.0);
coleccion.reemplazo(1.5);
coleccion.reemplazo(2.0);
coleccion.reemplazo(2.5);
coleccion.reemplazo(3.0);
coleccion.reemplazo(3.5);
coleccion.reemplazo(4.0);
coleccion.reemplazo(4.5);
coleccion.reemplazo(5.0);
break;
case 3:
coleccion.reemplazo(ingresarEntero("Ingrese un numero ",-100,100));
break;
}
System.out.println("\n¿Desea ingresar otro termino? 1--->Si 0--->No");
resp=Entrada.nextInt();
}while(resp!=0);
System.out.println("\nEl polinomio es: ");
coleccion.recorreLista();
}
}
import static java.lang.Math.pow;
public class Lista {
Nodo inicio;
Nodo fin;
public void agregarNodoAlFinal(Numero obj){
Nodo nuevo=new Nodo(obj);
Nodo reco1;
Nodo reco2;
if(inicio==null){
inicio=nuevo;
nuevo.setSiguiente(null);
}else{
reco1=inicio;
while(reco1!=null){
reco2=reco1.getSiguiente();
if(nuevo.getNum().getGrado()>=reco1.getNum().getGrado()){
nuevo.setSiguiente(inicio);
inicio=nuevo;
break;
}else{
if(nuevo.getNum().getGrado()nuevo.getNum().getGrado()&&reco2.getNum().getGrado()<=nuevo.getNum().getGrado()){
reco1.setSiguiente(nuevo);
nuevo.setSiguiente(reco2);
break;
}else{
reco1=reco1.getSiguiente();
}
}
}
}
}
}
public void recorreLista(){
Nodo aux=inicio;
while(aux!=null){
if(aux.getNum().getGrado()>=1){
System.out.printf(aux.getNum().getSigno()+aux.getNum().getNum()+"x^"+aux.getNum().getGrado());
aux=aux.getSiguiente();
}else{
System.out.printf(aux.getNum().getSigno()+aux.getNum().getNum());
aux=aux.getSiguiente();
}
}
System.out.println("\n");
}
public void reemplazo(double n){
Nodo aux=inicio;
int r=0;
double exp=0, re=0, base=0, acu=0;
while(aux!=null){
base=(double)aux.getNum().getNum();
exp=(double)aux.getNum().getGrado();
re= pow(n,exp);
if(aux.getNum().getSigno().compareTo("+")==0){
acu=acu+(base*re);
}
if(aux.getNum().getSigno().compareTo("-")==0){
acu=acu-(base*re);
}
aux=aux.getSiguiente();
}
System.out.printf("\nEl resultado del reemplazo de: "+"f("+n+")=");
recorreLista();
System.out.printf("f("+n+")= "+acu);
}
}
Clase Nodo
public class Nodo {
Numero num;
Nodo Siguiente;
public Nodo(Numero num) {
this.num = num;
}
public Numero getNum() {
return num;
}
public void setNum(Numero num) {
this.num = num;
}
public Nodo getSiguiente() {
return Siguiente;
}
public void setSiguiente(Nodo Siguiente) {
this.Siguiente = Siguiente;
}
}
Clase Númeropublic class Numero {
String signo;
int num;
int grado;
public Numero(String signo, int num, int grado) {
this.signo = signo;
this.num = num;
this.grado = grado;
}
public String getSigno() {
return signo;
}
public void setSigno(String signo) {
this.signo = signo;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getGrado() {
return grado;
}
public void setGrado(int grado) {
this.grado = grado;
}
}
Como corre el Programa
Crear una Clase Punto, luego crear un TAD-lista simple, implementar un método para calcular la distancia entre el Punto de origen y el cada punto de la lista. Final mente determinar el punto mas alejado del origen.
Clase Main
public class Principal {
public static void main(String[] args) {
Lista coleccion=new Lista();
coleccion.insertarInicio(new Punto(5,8.6));
coleccion.insertarInicio(new Punto(-8,10));
coleccion.insertarInicio(new Punto(15,108.6));
coleccion.insertarFinal(new Punto(-50,-45));
coleccion.insertarInicio(new Punto(-17,81));
System.out.println("El nodo mas distante al origen es "+coleccion.Distancia().getDato().toString());
}
Clase Lista
public class Lista {
Nodo inicio;
Nodo fin;
public Lista() {
inicio=null;
fin=null;
}
public void insertarInicio(Punto dato){
Nodo nuevo=new Nodo(dato, inicio);
inicio=nuevo;
if(fin==null)
fin=inicio;
}
public void insertarFinal(Punto dato){
Nodo nuevo=new Nodo(dato,null);
if(inicio==null){
inicio=nuevo;
}else{
fin.setSiguiente(nuevo);
fin=nuevo;
}
}
public Nodo Distancia(){
Punto origen=new Punto(0,0);
Nodo aux=inicio;
Nodo mayorDistancia=inicio;
double mayor=0;
double distancia=0;
while(aux!=null){
distancia=calculoDistancia(origen, aux.getDato());
if(distancia>mayor){
mayor=distancia;
mayorDistancia=aux;
}
aux=aux.getSiguiente();
}
return mayorDistancia;
}
public double calculoDistancia(Punto a, Punto b){
double distancia=( Math.pow(b.getY()-a.getY(), 2.0)+Math.pow(b.getX()-a.getX(), 2.0));
return distancia;
}
}
Clase Nodo
public class Nodo {
private Punto dato;
private Nodo siguiente;
public Nodo(Punto dato) {
this.dato = dato;
this.siguiente = null;
}
public Nodo(Punto dato, Nodo siguiente){
this.dato=dato;
this.siguiente=siguiente;
}
public Punto getDato() {
return dato;
}
public void setDato(Punto dato) {
this.dato = dato;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
}
Clase Punto
public class Punto {
private double x;
private double y;
public Punto() {
}
public Punto(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
@Override
public String toString() {
return "Punto (" + "x= " + x + ", y= " + y+")" ;
}
}
Como Corre el Programa
Crear
una lista simple la cual debe ingresar números reañes, luego ordenarlos de mayor a mayor, imprimir la lista, obtener el promedio de los valores de cada lista, comprobar cuál es el valor que más se repite en la lista.
Clase Main
import java.util.Scanner;
public class Principal {
public static void main (String args[]){
Lista insertar=new Lista();
Scanner sc= new Scanner (System.in);
int res,num;
System.out.println("¿Cuantos numeros desea ingresar?");
res=sc.nextInt();
for(int i=0;i
Clase Lista
public class Lista {
private Nodo raiz;
public Lista(){
raiz=null;
}
public void insertarDato (int dato){
Nodo nuevo=new Nodo(dato);
Nodo reco1;
Nodo reco2;
if(raiz==null){
raiz=nuevo;
nuevo.siguiente=null;
}else{
reco1=raiz;
while(reco1!=null){
reco2=reco1.siguiente;
if(nuevo.dato>=reco1.dato){
nuevo.siguiente=raiz;
raiz=nuevo;
break;
}else{
if(nuevo.datonuevo.dato&&reco2.dato<=nuevo.dato){
reco1.siguiente=nuevo;
nuevo.siguiente=reco2;
break;
}else{
reco1=reco1.siguiente;
}
}
}
}
}
}
public void listarNodos(){
Nodo temporal=raiz;
while(temporal!=null){
System.out.println("" +temporal.dato);
temporal=temporal.siguiente;
}
}
public void promedioNodos(){
Nodo temporal=raiz;
int cont=0;
double prom=0;
while(temporal!=null){
cont++;
prom=prom+temporal.dato;
temporal=temporal.siguiente;
}
System.out.println("El promedio es: " +prom/cont);
}
public void repite(){
int cont=0;
int a[]=new int[100];
int frecuenciaTemp, frecuenciaModa = 0, moda =0;
Nodo temporal=raiz;
while(temporal!=null){
cont++;
a[cont]=temporal.dato;
temporal=temporal.siguiente;
}
for(int i=0;i<=cont;i++){
frecuenciaTemp=0;
for(int j=0;j= frecuenciaModa){
frecuenciaModa = frecuenciaTemp;
moda = a[i];
}
}
}
System.out.println("El que mas se repite es " + moda);
}
}
Clase Nodo
public class Nodo {
int dato;
Nodo siguiente;
Nodo(int dato) {
this.dato=dato;
}
public int getDato() {
return dato;
}
public void setDato(int dato) {
this.dato = dato;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public Nodo(int dato, Nodo siguiente) {
this.dato = dato;
this.siguiente = siguiente;
}
}
Como corre el programa
en el primer ejercicio me sale error
ResponderBorrarsi ami me sale error en el primero
ResponderBorrarpara el primero como podria ser la clase lista usando LinkedList ?????
ResponderBorrarme gustaria saber como seria el primer algoritmo del polinomio usando LinkedList, porque el que esta ahi tiene muchos errores.
ResponderBorrarEste comentario ha sido eliminado por el autor.
ResponderBorrarel error que aparece en la clase lista del primer ejercicio se soluciona asi:
ResponderBorrarif(nuevo.getNum().getGrado()>=reco1.getNum().getGrado()){
tambien tienen que borrar un } que sobra y ya, creo que eso es todo, a mi ya me funciona perfecto.