Ejercicio 1
Problema:
Crear una lista simple la cual debe ingresar números reales, luego ordenarlos de mayor a menor, 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.
Explicación: Se desarrollaran tres clases una clase Nodo, una Lista y una principal, los nodos deben ser simplemente enlazados dado los requerimientos del usuario. También se puede notar que los nodos deben poseer una variable float en base al problema, el ordenamiento se realizara mediante un método de ordenamiento de los ingresos, la impresión mediante un ciclo repetitivo basado en el tamaño dinámico de la lista, el resto de funciones harán uso de un ciclo similar para su desarrollo con ajustes en base a lo necesitado.
public class Nodo {
private Nodo siguiente;//Lista simplemente enlazada
private float info;
public Nodo(float info,Nodo siguiente){
this.info=info;
this.siguiente=siguiente;
}
public Nodo(float info){
this.info=info;
siguiente=null;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public float getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}
Explicación: Se generara un clase lista simple en la cual los nodos tengan como parámetro un valor entero y una referencia al nodo siguiente. En base a esta Lista se generara un método capaz de encontrar un valor dado en este caso por un entero y generar entre dichos nodos un nuevo nodo cuyo dato entero sea el valor absoluto de las diferencia entre estos valores.
Para generar dicho método se hará uso de un contado el cual mantenga constancia del numero de nodos en la lista, y se generara el nuevo nodo después del nodo indicado, para el calculo de los valores se usara el método abs de la clase Math.Como dato final se decidió obviar el calculo después del ultimo dato debido a la falta de un segundo dato para el calculo del valor absoluto.
Explicación:
El uso de listas doblemente enlazadas facilitan la búsqueda de valores y la referencia a
elementos con respecto a sus nodos.
Para la comparación de caracteres se hará uso de la Clase Character por su facilidad al
permitir el uso de
funciones como: compareTo, la cual se utilizara en el ordenamiento de la lista.
Se hará uso de una función organizadora de los ingresos para evitar problemas con
la alteración del orden de los nodos.
Crear una lista simple la cual debe ingresar números reales, luego ordenarlos de mayor a menor, 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.
Explicación: Se desarrollaran tres clases una clase Nodo, una Lista y una principal, los nodos deben ser simplemente enlazados dado los requerimientos del usuario. También se puede notar que los nodos deben poseer una variable float en base al problema, el ordenamiento se realizara mediante un método de ordenamiento de los ingresos, la impresión mediante un ciclo repetitivo basado en el tamaño dinámico de la lista, el resto de funciones harán uso de un ciclo similar para su desarrollo con ajustes en base a lo necesitado.
Clase Nodo: Nodos simplemente enlazados
public class Nodo {
private Nodo siguiente;//Lista simplemente enlazada
private float info;
public Nodo(float info,Nodo siguiente){
this.info=info;
this.siguiente=siguiente;
}
public Nodo(float info){
this.info=info;
siguiente=null;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public float getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}
Clase lista:
public class Lista {
private Nodo inicio;
private Nodo fin;
public Lista(){
inicio=fin=null;
}
public void imprimirLista(){ //Función que imprime la lista desde su inicio hasta el fin
Nodo aux=inicio;
int cont=1;
while(aux!=null){// Ciclo de repetición que pasa la lista desde inicio a fin
System.out.println(cont+" "+aux.getInfo());
cont++;//Contador tipo entero para la lista
aux=aux.getSiguiente();
}
}
public float promedioLista(){ //Función que calcula el prommedio de la lista
Nodo aux=inicio;
float cont=0;//auxiliar en donde se guardara el valor de cada Nodo
int total=0;//auxiliar en donde se guardara el total de Nodos en la Lista
while(aux!=null){// Ciclo de repetición que pasa la lista desde inicio a fin
cont=cont+aux.getInfo();
total++;
aux=aux.getSiguiente();
}
return cont/total;
}
public float contador(){//Metodo que cuenta el valor que mas se repite en la lista
Nodo aux=inicio;
int contMay=0,contOtro=0;
float mayor=0,otro=0;
if(aux!=null){//comprueba que la lista no este vacia para hacer referencia a la información del nodo inicio
otro=aux.getInfo();
while(aux!=null){
if(otro==aux.getInfo()){//Si el valor es igual al anterior se mantiene contando
contOtro++;
}else{
if(contMay<=contOtro){//Al variar el valor se hace el cambio de variable en base a si este contador fue mayor al anterior
mayor=otro;
contMay=contOtro;
contOtro=1;//Se inicia en uno, debido a que el valor se calcula en una sentencia anterior
otro=aux.getInfo();
}else{
otro=aux.getInfo();
contOtro=1;
}
}
aux=aux.getSiguiente();
}
}
if(contMay<contOtro){//Se comprueba al final para determinar si el valor enviado es el correcto
return otro;
}
return mayor;
}
public void agregarNodoOrdenado(float info){//Ordena la lista, ingresando cada nuevo Nodo en un posición en base a su valor
Nodo ingreso= new Nodo(info);
if(inicio==null){//si la lista esta vacia
inicio=fin=ingreso;
ingreso.setSiguiente(null);
}else{
if(inicio.getInfo()<=ingreso.getInfo()){//si es menor o igual el valor nuevo al inicio
ingreso.setSiguiente(inicio);
inicio=ingreso;
}else{
if(fin.getInfo()>=ingreso.getInfo()){//Si es menor que el final de la Lista
fin.setSiguiente(ingreso);
fin=ingreso;
}else{
Nodo aux=inicio;
Nodo aux2=inicio.getSiguiente();
while(aux2!=null){//Determina el siguiente valor mas pequeño, va alterando en medio de la lista
if(aux2.getInfo()<ingreso.getInfo()){
break;
}
aux=aux2;
aux2=aux2.getSiguiente();
}
if(aux2.getInfo()<ingreso.getInfo()&&aux2!=null){//Realiza la asignacion del valor obtenido
aux.setSiguiente(ingreso);
ingreso.setSiguiente(aux2);
}
}
}
}
}
}
Clase principal:
import java.util.Scanner;
public class Principal {
public static void main(String[] args) {
// TODO Auto-generated method stub
Lista l=new Lista();
int menu=0;
do{
menu=leerInt("----Menu----"
+ "\n1.Ingresar valor a la tabla"
+ "\n2.Imprimir Lista"
+ "\n3.Calcular promedio"
+ "\n4.Contar mayor numero repetido"
+ "\n0.Salir");
switch(menu){
case 1:{
l.agregarNodoOrdenado(leerFloat("Ingrese el valor del nodo"));
break;
}
case 2:{
l.imprimirLista();
break;
}
case 3:{
System.out.println("El promedio de la lista es de "+l.promedioLista());
break;
}
case 4:{
System.out.println("El valor que mas se repite en la base de datos es: "+l.contador());
break;
}
case 0:{
System.out.println("Programa Terminado");
break;
}
}
}while(menu!=0);
}
public static int leerInt(String texto){
Scanner leer=new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
public static float leerFloat(String texto){
Scanner leer=new Scanner(System.in);
System.out.println(texto);
return leer.nextFloat();
}
}
Ejercicio 2
Problema: Crear una lista simple enlazada de números enteros, se desea añadir un nodo entre dos nodos consecutivos; el dato del nuevo nodo debe ser la diferencia en valor absoluto de los dos nodos.
Ejemplo si tengo la siguiente lista
Explicación: Se generara un clase lista simple en la cual los nodos tengan como parámetro un valor entero y una referencia al nodo siguiente. En base a esta Lista se generara un método capaz de encontrar un valor dado en este caso por un entero y generar entre dichos nodos un nuevo nodo cuyo dato entero sea el valor absoluto de las diferencia entre estos valores.Para generar dicho método se hará uso de un contado el cual mantenga constancia del numero de nodos en la lista, y se generara el nuevo nodo después del nodo indicado, para el calculo de los valores se usara el método abs de la clase Math.Como dato final se decidió obviar el calculo después del ultimo dato debido a la falta de un segundo dato para el calculo del valor absoluto.
Clase Nodo
public class Nodo {
private Nodo siguiente;
private int info;
public Nodo(int info) {
this.info = info;
}
public Nodo(Nodo siguiente, int info) {
this.siguiente = siguiente;
this.info = info;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public int getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}
Clase Lista
public class Lista {
private Nodo inicio;
private Nodo fin;
public Lista(){
inicio=fin=null;
}
public void imprimir(){
Nodo aux=inicio;
int cont=1;
while(aux!=null){
System.out.println(cont+" "+aux.getInfo());
cont++;
aux=aux.getSiguiente();
}
}
public void agregarNodo(int valor){//Funcion basica para agregar un valor al final de un lista simple
Nodo nuevo= new Nodo(valor);
if(fin!=null){
fin.setSiguiente(nuevo);
}else{
inicio=nuevo;
}
fin=nuevo;
}
public void agregarValor(int pos){
int cont=1;
Nodo aux=inicio;
Nodo aux2=inicio.getSiguiente();
if(pos<cont()&&pos>1){//Se controla que el numero ingresado sea valido para la ejecucion de la aplicacion.
while(aux2!=null){//se controla en base a la cual se mas posible llegue a ser un valor nulo
if(cont==pos){//si se encuentra un valor igual al especificado se rompe el ciclo
break;
}
cont++;
aux=aux2;
aux2=aux2.getSiguiente();
}
if(cont==pos&&aux2!=null){//Si los valores son iguales se agrega el valor absoluto entre los dos nodos.
Nodo nuevo=new Nodo(Math.abs(aux.getInfo()-aux2.getInfo()));
aux.setSiguiente(nuevo);
nuevo.setSiguiente(aux2);
}
}
}
public int cont(){//Realiza el calculo del numero total de valores de la lista
Nodo aux=inicio;
int cont=0;
while(aux!=null){
cont++;
aux=aux.getSiguiente();
}
return cont;
}
}
Clase Principal
import java.util.Scanner;
public class Principal {
public static void main(String[] args) {
// TODO Auto-generated method stub
Lista l=new Lista();
int menu=0,aux;
do{
menu=leerInt("----Menu----"
+ "\n0.Salir"
+ "\n1.Agregar Entero a la Lista"
+ "\n2.Imprimir Lista"
+ "\n3.Agregar un valor absoluto despues del Nodo");
switch(menu){
case 0:{
System.out.println("Programa Terminado");
break;
}
case 1:{
l.agregarNodo(leerInt("Ingrese el valor a agregar a la lista"));
break;
}
case 2:{
l.imprimir();
break;
}
case 3:{
aux=leerInt("Ingrese la posicion despues de la cual se agregara el valor absoluto");
if(aux>=l.cont()||aux<1){//Se limita el ingreso para tener dos valores entre los cuales ingresar el nuevo dato
System.out.println("Valor fuera del rango de la lista");
}else{
l.agregarValor(aux);
System.out.println("Valor agregado a la lista");
}
break;
}
}
}while(menu!=0);
}
public static int leerInt(String texto){
Scanner leer= new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
}
Ejercicio 3
Escribir un programa para obtener una lista doblemente enlazada con los caracteres de
una cadena leída desde el teclado. Cada nodo de la lista tendrá un carácter. Una vez que
se haya creado la lista, ordenarla alfabéticamente y escribirla en pantalla
El uso de listas doblemente enlazadas facilitan la búsqueda de valores y la referencia a
elementos con respecto a sus nodos.
permitir el uso de
funciones como: compareTo, la cual se utilizara en el ordenamiento de la lista.
Se hará uso de una función organizadora de los ingresos para evitar problemas con
la alteración del orden de los nodos.
Clase NODO:
public clss Nodo {
private Nodo anterior;
private Nodo siguiente;//Al ser doblemente enlazadas contiene una referencia a un nodo anterior y siguiente.
private Character info;//La clase Character funciona similar a un char pero permite el uso de funciones
public Nodo(Nodo anterior, Nodo siguiente, char info) {
this.anterior = anterior;
this.siguiente = siguiente;
this.info = info;
}
public Nodo(char info) {
anterior=siguiente=null;
this.info = info;
}
public Nodo getAnterior() {
return anterior;
}
public void setAnterior(Nodo anterior) {
this.anterior = anterior;
}
public Nodo getSiguiente() {
return siguiente;
}
public void setSiguiente(Nodo siguiente) {
this.siguiente = siguiente;
}
public char getInfo() {
return info;
}
public void setInfo(char info) {
this.info = info;
}
}
Clase LISTA:
public class Lista {
public Nodo inicio;
public Nodo fin;
public Lista(){
inicio=fin=null;
}
public void iniciar(String texto){
inicio=fin=null;//En caso de usarse nuevamente, se borra el contenido de la Lista anterior
Nodo nuevo;
int i;
for(i=0;i<texto.length();i++){
agregarOrdenado(texto.charAt(i));//Agrega los valores del String en orden al momento de inicializar
}
}
public void agregarNodo(char a){//Funcion que agrega un Nodo al final de la lista
Nodo nuevo=new Nodo(fin,null,a);
if(fin!=null){
fin.setSiguiente(nuevo);
fin=nuevo;
}else{
inicio=fin=nuevo;
}
}
public void imprimir(){//Funcion que imprime la Lista de inicio a fin
Nodo aux=inicio;
int cont=1;
while(aux!=null){
System.out.println(cont+""+aux.getInfo());
cont++;
aux=aux.getSiguiente();
}
}
public void agregarOrdenado(Character valor){//Funcion que agrega un nodo a lista alfabéticamente a-z
Nodo nuevo=new Nodo(valor);
if(inicio==null){//Compara si la lista esta vacia
agregarNodo(valor);
}else{
if(valor.compareTo(inicio.getInfo())<=0){//Compara si el caracter es menor que el inicio a<z
nuevo.setSiguiente(inicio);
inicio.setAnterior(nuevo);
inicio=nuevo;
}else{
if(valor.compareTo(fin.getInfo())>=0){//compara si el caracter es mayor que el fin z>a
agregarNodo(valor);
}else{
Nodo aux=inicio;
while(aux.getSiguiente()!=null){
if(valor.compareTo(aux.getSiguiente().getInfo())<0){//Busca en la lista hasta su final un valor mayor que el del caracter para su ingreso
break;
}
aux=aux.getSiguiente();
}if(aux.getSiguiente()!=null){//Si existe el valor esperado
if(valor.compareTo(aux.getSiguiente().getInfo())<0){//Se ingresa el valor a la lista y se realizan las conecciones necesarias
nuevo.setAnterior(aux);
nuevo.setSiguiente(aux.getSiguiente());
aux.getSiguiente().setAnterior(nuevo);
aux.setSiguiente(nuevo);
}
}
}
}
}
}
}
Clase Principal:
import java.util.Scanner;
public class Principal {
public static void main(String[] args) {
// TODO Auto-generated method stub
Lista l=new Lista();
int menu=0;
do{
menu=leerInt("----Menu----"
+ "\n0.Salir"
+ "\n1.Generar Lista en base a una cadena de caracteres"
+ "\n2.Imprimir Lista");
switch(menu){
case 0:{
System.out.println("Programa Terminado");
break;
}
case 1:{
l.iniciar(leerString("Ingrese la palabra para generar la lista"));
break;
}
case 2:{
l.imprimir();
break;
}
}
}while(menu!=0);
}
public static int leerInt(String texto){
Scanner leer=new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
public static String leerString(String texto){
Scanner leer=new Scanner(System.in);
System.out.println(texto);
return leer.nextLine();
}
}
No hay comentarios:
Publicar un comentario