miércoles, 18 de noviembre de 2015

Ejercicios Basicos Pilas y Colas

Realice un procedimiento que cuente la cantidad de elementos de una cola. Lo mismo  para un pila.La estructura debe quedar en su estado original.

Ejemplo Colas:

Clase Cola:


public class Cola {
private NodoCola inicio;
private NodoCola fin;

public void agregar(int valor){
NodoCola nuevo= new NodoCola(valor);
if(vacia()){
inicio=nuevo;
}else{
fin.setSiguiente(nuevo);
}
fin=nuevo;
}
public boolean vacia(){
return inicio==null;
}
public int cont(){
int cont=0;
NodoCola aux=inicio;
while(aux!=null){
cont++;
aux=aux.getSiguiente();
}
return cont;
}
public void imprimir(){
int cont=1;
NodoCola aux=inicio;
while(aux!=null){
System.out.println(cont+". "+aux.getInfo());
cont++;
aux=aux.getSiguiente();
}
}
}

Clase NodoCola:


public class NodoCola {
private NodoCola siguiente;
private int info;
public NodoCola(int info,NodoCola siguiente) {
this.siguiente = siguiente;
this.info = info;
}
public NodoCola(int info) {
this.info = info;
siguiente=null;
}
public NodoCola getSiguiente() {
return siguiente;
}
public void setSiguiente(NodoCola siguiente) {
this.siguiente = siguiente;
}
public int getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}

Clase Principal:

import java.util.Scanner;


public class Principal {

public static void main(String[] args) {
// TODO Auto-generated method stub
Cola c=new Cola();
int menu=0;
do{
menu=leerInt("----Menu----"
+ "\n0.Salir"
+ "\n1.Ingresar Datos"
+ "\n2.Imprimir Cola"
+ "\n3.calcula numero de datos");
switch(menu){
case 0:{
System.out.println("Programa Terminado");
break;
}
case 1:{
c.agregar(leerInt("Ingrese el valor del dato a agregar a la cola"));
break;
}
case 2:{
c.imprimir();
break;
}
case 3:{
System.out.println("El numero de datos en la cola es de: "+c.cont());
break;
}
}
}while(menu!=0);
}
public static int leerInt(String texto){
Scanner leer=new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
}

Ejemplo Pila:

Clase Pila:


public class Pila {
private NodoPila cima;
public Pila(){
cima=null;
}
public void imprimir(){
NodoPila aux=cima;
int cont=cont();
while(aux!=null){
System.out.println(cont+" "+aux.getInfo());
cont--;
aux=aux.getAnterior();
}
}
public int cont(){
NodoPila aux=cima;
int cont=0;
while(aux!=null){
cont++;
aux=aux.getAnterior();
}
return cont;
}
public void agregarNodo(int valor){
NodoPila nuevo=new NodoPila(valor,cima);
cima=nuevo;
}
}

Clase NodoPila:


public class NodoPila {
private int info;
private NodoPila anterior;
public NodoPila(int info, NodoPila anterior) {
this.info = info;
this.anterior = anterior;
}
public NodoPila(int info) {
this.info = info;
anterior=null;
}
public int getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
public NodoPila getAnterior() {
return anterior;
}
public void setAnterior(NodoPila anterior) {
this.anterior = anterior;
}
}

Clase Principal:

import java.util.Scanner;


public class Principal {

public static void main(String[] args) {
// TODO Auto-generated method stub
Pila p=new Pila();
int menu=0;
do{
menu=leerInt("-----Menu-----"
+ "\n0.Salir"
+ "\n1.Ingresar dato a la pila"
+ "\n2.Imprimir pila"
+ "\n3.Calcular numero de elementos pila");
switch(menu){
case 0:{
System.out.println("Programa terminado");
break;
}
case 1:{
p.agregarNodo(leerInt("Ingrese el valor numerico a agregar a la pila"));
break;
}
case 2:{
p.imprimir();
break;
}
case 3:{
System.out.println("El numero de elementos en la pila es de: "+p.cont());
break;
}
}
}while(menu!=0);
}

public static int leerInt(String texto){
Scanner leer= new Scanner(System.in);
System.out.println(texto);
return leer.nextInt();
}
}

Referencias:



  • Carolo, g(s,n).Listas,Pilas y Colas.Recuperado el 18 de noviembre de 2015 de http://es.slideshare.net/izyalyth/ay-p2-ejercicioslistaspilascolas

Pilas y Colas

Pilas:

Una pila es una estructura para el almacenamiento de datos, en la cual la información posee solamente una entrada y salida para su acceso, es decir mantiene una estructura LIFO(Last in First out) lo que quiere decir que el ultimo elemento ingresado debe ser el primero al cual accedemos, por ende el primer elemento ingresado puede solamente ser visto si pasamos por todos los elementos de la Pila.Dentro de java podemos acceder a este tipo de clase mediante el uso de la clase Stack.


A continuación dejo un vídeo sobre el tema del canal de youtube de MasterHeHeGar, un profesor de informática, el cual realiza una explicación a mas detalle del tema.


Colas:

Una cola es un tipo de dato abstracto con una estructura FIFO(First in First out), el cual tiene un comportamiento similar a la pila, con la diferencia notable de poseer un canal de ingreso y un canal de acceso ubicados en extremos opuestos de la estructura, es decir se agrega información de igual manera que en una pila sobreponiendo cada elemento encima del anterior, pero al intentar acceder se realiza este proceso a partir del primer dato ingresado.


Tipos de Colas:


Colas simples: su funcionamiento es el planteado durante la explicación, el ingreso y el final de la cola se encuentran en extremos opuestos de la estructura, de manera en que el primer dato insertado sera el primero leído.

Colas circulas: planteados con una referencia al cíclica, después de acceder al ultimo elemento se regresa a acceder al primero de la lista.

Colas con prioridad: este tipo de estructura permite el acceso a la información mediante un valor de prioridad otorgado por el usuarios al momento de su ingreso, en este tipo de colas si se encuentran varios elementos con igual prioridad, se accede primero a aquellos que lleguen primero.
 

Al igual que con el anterior tema, dejo un video del canal de youtube de MasterHeHeGar, en el cual se ve mas a profundidad el tema, y se ve como implementar este tipo de estructura de información.



Comparación Pilas y Colas:

Tanto pilas como colas, son estructuras de abstractas con el propósito de almacenar información, la diferencia entre ambas radica en el acceso de información, mientras que ambas sobreponen sus datos encima el ultimo dato ingresado, en una pila la información solo puede ser accedido desde el ultimo dato ingresado, mientras que en una cola el acceso se hace desde el primer dato ingresado, en sus caso básico, y este acceso se altera para los diferentes tipos de colas que se pueden hacer.


Referencias:

  • Alvarez,D.(2011).Pilas en Java.Recuperado el 18 de noviembre de 2015 de http://soloinformaticayalgomas.blogspot.com/2011/02/pilas-en-java.html
  • Sierra,M(s,n).La estructura de datos pila en java.Clase Stac del API Java.Ejemplo Simple y ejercicios resueltos.Recuperado el 18 de noviembre de 2015 de http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=608:la-estructura-de-datos-pila-en-java-clase-stack-del-api-java-ejemplo-simple-y-ejercicios-resueltos-cu00920c&catid=58:curso-lenguaje-programacion-java-nivel-avanzado-i&Itemid=180
  • Alvarez,D.(2011).Colas en Java.Recuperado el 18 de noviembre de 2015 de http://soloinformaticayalgomas.blogspot.com/2011/03/colas-en-java.html



martes, 17 de noviembre de 2015

Ejercicio 2 - Portafolio


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
 |   20   |   |   43   |  |   17   |  |   4    |  |    11   |
Se dese insertar un dato entre 43 y 17.
Reviso que exista la secuencia
Luego calculo el valor absoluto de (43-17)
Inserto entre esos elementos.
 |   20   |   |   43   |  |   26  |  |   17   |  |   4    |  |    11   |


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 - Portafolio

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

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.


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();
}
}

Ejercicio 1 - Portafolio

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.

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();
}
}