primero
vedemos saber que es un nodo y que es un puntero
vedemos saber que son para seguir con el siguiente tema la
información que se mostrara a continuación es gracias a nuestro catedrático
ing. José Reynaldo Molina Menjívar. quien nos
aportó la información ahora mostrada
¿Qué es un nodo?
Un nodo es un
elemento de una Lista Enlazada, cada nodo será una estructura o registro que
dispondrá de varios campos y al menos uno de esos campos será un puntero o
referencia a otro nodo.
lo que yo entiendo sobre esta información es lo siguiente que un nodo es una estructura de espacios donde se puede tener texto o números. todos esos campos serán parte del nodo y almenos uno debe ser un puntero al otro nodo
¿Qué es un Puntero?
Un puntero o Apuntador es una variable que hace
referencia a una región de la memoria. lo que yo entiendo se puntero o apuntador según e investigado es que un puntero o apuntador es una variable para almacenar direcciones y accede a la información que contiene la dirección de la memoria a la que apunta
CLASE
NODO
Public class Nodo {<---------------------Estructura
public
int dato;<-----------------------contenido del nodo
public
Nodo siguiente;<---------------------puntero siguiente
Una lista enlazada consta de un número de elementos, y cada elemento tiene dos componentes (campos), una referencia al siguiente elemento de la lista y un valor, que puede ser de cualquier tipo . En resumen una lista enlazada es una colección o secuencia de elementos dispuestos uno detrás de otro, en la que cada elemento se conecta al siguiente elemento por un “enlace” o “referencia”.
La representación gráfica más extendida es aquella que utiliza una caja (un rectángulo) con dos secciones en su interior. En la primera sección se escribe el elemento o valor del dato, y en la segunda sección, el enlace o referencia mediante una flecha que sale de la caja y apunta al nodo siguiente
La Figura muestra diferentes representaciones gráficas utilizadas para dibujar el campo enlace del último nodo.
Aquí tenemos 2 ejemplos en la aplicación de algoritmos recursivos:
SUCESION DE fibonacci
La sucesión de Fibonacci es conocida desde hace miles de años, pero fue
Fibonacci (Leonardo de Pisa) quien la dio a conocer al utilizarla para resolver
un problema.
El primer y segundo término de la sucesión son
Los siguientes términos se obtienen sumando los dos términos que les preceden:
El tercer término de la sucesión es
El cuarto término es
El quinto término es
El sexto término es
El (n+1)-ésimo término es
EJERCICIO EN JAVA
TORRES DE HANOI
El fin de las Torres de Hanoi es trasladar la
torre de discos a lo largo de tres varillas, desde la configuración inicial a
una configuración final indicada. Esta torre està fraccionada en bloques o
discos, los cuales deberá mover para restaurar de nuevo la torre en su posición
final.
La segunda varilla consiste en una torre de
“apoyo” que le permite colocar los discos de manera temporal. No obstante, uno
de los requerimientos de la prueba es que debe realizar el menor número de
movimientos posible y con el menor número de fallos.
EJERCICIO EN JAVA ejercicio realisado por ing. José Reynaldo Molina Menjívar.
package torreshanoi;
/**
*
* @author NormanGhost
*/
public class
TorresHanoi {
public static void main(String[] args) {
System.out.print ("Torres de
hanoi");
TorresHanoi objHanoi = new
TorresHanoi();
objHanoi.torresHanoi (3,1,2,3);
System.out.println("juego
Finalisado...XD");
}
//creando metodo recursivo para solucionar la torre de hanoi
public void torresHanoi(int discos , int torre1 , int
torre2 , int torre3){
if
(discos==1){
System.out.println("Mover disco de torre "+torre1+" a
torre "+torre3);
}else{
torresHanoi(discos-1,torre1,torre3,torre2);
System.out.println("Mover disco de torre "+torre1+" a
torre "+torre3);
Como su nombre lo indica la recursibidad va utilizando los mismos recursos contantementes haciendo que el problema sea mas facil de ejecutar.
Pondremos un ejemplo muy sencillo: La muñeca Matrushka, esta muñeca de madera contiene dentro otra muñeca cada vez mas pequeña.
En Java S
Este es el objeto que vamos a utilizar cuando hablemos de algoritmos recursivos que cumplirán una función dentro del mismo procedimiento
La recursividad es una alternativa diferente para implementar estructuras de repetición (ciclos) también la podemos utilizar en cualquier situación en la cual la solución pueda ser expresada como una secuencia.
Por que es importante utilizar la recursividad en Java?
La recursión permite programar algoritmos aparentemente complicados con un código simple y claro, ahorrando trabajo al programador. A simple vista parece la solución perfecta para muchos problemas, pero hay que tener en cuenta que en ocasiones ralentizará el programa en exceso. Por ejemplo, la función factorial en forma recursiva:
Memoria Dinámica: La memoria dinámica es lo contrario
a la memoria estática. su tamaño crece durante su ejecución, por lo que hemos investigado
sobre la memora dinámica es que la memoria dinámica su espacio puede variar
durante la ejecución del programa.
Como podemos diferenciar entre una memoria dinámica y una memoria
estática.
La memoria estática:
Supongamos
que tenemos un vector de 5 espacios que iremos llenando empezando desde 0
terminando asta índice máximo de este vector que es <5
Una vez que el vector este lleno ya no se podrá almacenar
mas datos como lo realizamos en el ejercicio anterior definimos un límite de
ingresos que podría realizar el usuario.
La memoria
dinámica:
Supongamos que realizamos un ingreso de un dato creamos un
vector una ves lleno podemos preguntar al usuario si desea ingresar otro dato
Si el usuario responde si tendremos un vector de 2 espacios
y así continuamente podemos seguir hasta donde el usuario defina que ya no desea
ingresar mas datos
A continuación, explicaremos un poco sobre la memoria dinámica
con un ejercicio este ejercicio fue realizado en una clase Estructura de Datos en
la universidad Cristiana de las Asambleas de Dios impartida por el ing. José
Reynaldo Molina Menjívar.
El nombre de nuestro proyecto será javaapplication6
En el primer paso creamos un objeto de ArrayList
llamado cadenas declaramos que cadenas será nuestro nuevo arraylist.declaramos dos
variables tipo String una llamada respuesta y otra llamada frase.
En el segundo paso capturamos la frase, declaramos
que frase será igual al dato ingresado por el usuario mostrando el
mensaje ingrese la frase dando a entender al usuario que deberá ingresar
una frase.
En el tercer paso agregamos la frase al arraylist cadenas.add(frase)
En el cuarto paso preguntamos si deseamos ingresar
otra frase si la respuesta es sí repetirá el proceso ingresando una
nueva frase. solo cuando la respuesta sea no pasaremos al siguiente paso
que es el paso 5.
En el quinto paso mostraremos el contenido del
arraylist para ello utilisaremos el metoso SIZE y GET del arraylist donde
el size Devuelve la cantidad de elementos del arrarylist y el get nos
devuele el elemento indicado
package javaapplication6;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public
class javaapplication6 {
public static void main(String[] args) {
//PASO 1: HACER UN OBJETO DE
ARRAYLIST
ArrayList <String> cadenas;
cadenas = new ArrayList
<String>();
String frase, respuesta;
do{
//paso
2:capturar la frace
frase =
JOptionPane.showInputDialog(null,"Ingrese la frace");
//paso
3: agregar una frace al ARRAYLIST
cadenas.add(frase);
//paso
4: preguntar si desea continuar o no
respuesta = JOptionPane.showInputDialog(null,"desea ingresar otra
frase ( SI/ NO )");
respuesta = respuesta.toUpperCase();
}while(respuesta.equals("SI"));
//paso 5:
mostrar el contenido ArrayList
//VAMOS A
UTILISAR AQUI LOS METODOS SIZE Y GET DEL ARRAY LIST
antes de hablar sobre memoria estática debemos conocer que es la memoria .
La memoria: la memoria es un espacio para guardar la
información. Por lo que entiendo de memoria según e investigado Son partes
lógicas dentro de partes físicas (memoria RAM) por lo tanto cuando la
información es ingresada la memoria nos ayuda a almacenar esta información.
Memoria estática:Es un espacio de la memoria que
mientras esta en tiempo de ejecución esta no puede ser modificada, por lo que
entiendo de memoria estática es un espacio definido o reservado y mientras el
programa está en ejecución esta no podrá ser modificada solo hasta que esta
termine de ejecutarse y cuando ya no este ejecutándose podremos volves al
código y podremos modificarlo.
·A continuación, con la ayuda de un ejercicio
realizado en una clase de estructura de datos impartida en la Universidad
cristiana de las asambleas de Dios por el Ing. José Reynaldo Molina Menjívar.
darémos a explicar un ejercicio sobre la memoria estatica.
oEn la parte 1podemos observar que
declaramos los arreglos así que declaramos que los arreglos serán de tipo int
para almacenar los enteros y string para texto, pero como podemos observar
tenemos limite de 5 espacios para guardar distintos datos en él, ya que este no
puede ser modificado en el tiempo de la ejecución.
oEn la parte 2 capturamos los datos de que
el usuario ingrese y con la ayuda de un for declaramos un incremento para empezar
desde 0 y terminar en menos 5 para capturar solo 5 datos.
oEn la parte 3 imprimimos y mostramos los
datos del arreglo.
oEn la parte 4 ordenamos los elementos del
array numérico con la ayuda de un Arrays.sort(numeros).
oEn la parte 5 rellenamos los arreglos con
palabras con la ayuda de un array.fill
oY por último en la parte 6 copiamos los
elementos de números a numero2 con un arrarycopy
Ejercico:
package javaapplication6;
import
java.util.Arrays;
import
javax.swing.JOptionPane;
public
class javaapplication6 {
public static void main(String[] args) {
// P1. DECLARAR LOS ARREGLOS
int numeros[] = new int[5];
int numeros2[] = new
int[numeros.length];
String palabras[] = new
String[5];
// P2.
CAPTURAR LOS DATOS QUE EL USUARIO INGRESE
int i;
//INCREMENTO
for (i=0; i<5;i++){
numeros[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingresa
el elemento: " + i));
}
//P3.
MOSTRAR LOS DATOS DEL ARREGLO
System.out.println("Los datos sin ordenar son: ");
for (i=0; i<5; i++){
System.out.println("["+numeros[i]+"]");
}
//P4.
ORDERNAR LOS ELEMENTOS DEL ARRAY NUMEROS
System.out.println("Los elementos ordenados son:");
Arrays.sort(numeros); // ACA SE ORDENAN LOS ELEMENTOS DEL ARREGLO
for (i=0; i<5; i++){
System.out.println("["+numeros[i]+"]");
}
//P5.
RELLENAR EL ARREGLO CON PALABRAS
Arrays.fill(palabras,"Voy a pasar la Materia");
for (i=0; i<5; i++){
System.out.println("["+palabras[i]+"]");
}
//P6.
COPIANDO LOS ELEMENTOS DEL ARREGLO NUMEROS A NUMEROS2
