ESTRUCTURA DE DATOS

INSTITUTO TECNOLOGICO NACIONAL DE MEXICO

INSTITUTO TECNOLOGICO DE ORIZABA

INFORMATICA

“ESTRUCTURA DE DATOS”

REPORTE UNIDAD II “RECURSIVIDAD”

GRUPO
3a3A

PRESENTA
MARTINEZ FLORES MOISES
RAMIREZ CAMARENA KEVIN OSCAR

HORA: 15:00 – 16:00

06/JUNIO/2021
Introducción.

Primero debemos decir que la recursividad no es una estructura de

datos, sino que es una técnica de programación que nos permite que
un bloque de instrucciones se ejecute n veces. Remplaza en ocasiones
a estructuras repetitivas.
La recursividad es un concepto difícil de entender en principio, pero
luego de analizar diferentes problemas aparecen puntos comunes.
En Java los métodos pueden llamarse a sí mismos. Si dentro de un
método existe la llamada a sí mismo decimos que el método es
recursivo.
Cuando un método se llama a sí mismo, se asigna espacio en la pila
para las nuevas variables locales y parámetros.
Al volver de una llamada recursiva, se recuperan de la pila las variables
locales y los parámetros antiguos y la ejecución se reanuda en el punto
de la llamada al método.
Marco teórico.
RECURSIVIDAD:
Es un concepto amplio con muchas variantes, y difíciles de precisar con poca
palabras aparece en numerosas actividades de la vida diaria,. La recursión es un
recurso poderoso que permite expresar soluciones simples y naturales a ciertos
tipos de problemas. Es muy importante considerar que no todos los problemas son
naturalmente recursivos. Algunos si lo son y otros no la recursión se puede
representar de dos maneras
• Directa: el programa o subprograma se llama directamente a si mismo
• Indirecta: el programa llama a otro subprograma y este en algún momento
llama nuevamente al primero.
Ejemplo:
Programa Java recursivo para calcular 2 elevado a n siendo n un número entero
mayor o igual que 0.

La solución recursiva se basa en lo siguiente:

Caso Base:

si n = 0 entonces 2^0 = 1

Si n > 0 Podemos calcular 2^n como 2 * 2^n-1

Por ejemplo: 2^5 = 2 * 2^4

import java.util.*;
public class Elevar2aN {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num;
do{
System.out.print("Introduce un numero entero >=0 ");
num = sc.nextInt();
}while(num<0);
System.out.println("2 ^ " + num + " = " + potencia(num));
}
public static double potencia(int n){
if(n==0) //caso base
return 1;
else
return 2 * potencia(n-1);
}
}
Recursos, materiales y equipo
• Computadora
• IDE NETBEANS,
• JDK.
• Lectura de los materiales de apoyo del tema 1 (AULA MOODLE, O Link de
Consulta)
• Clase Tools.
COMPETENCIAS.

A desarrollar:
Conoce, comprende y aplica eficientemente estructuras de datos, métodos de
ordenamiento y búsqueda
para la optimización del rendimiento de soluciones a problemas del mundo real

Específica(s):
Aplica la recursividad en la solución de problemas valorando su pertinencia en el
uso eficaz de los recursos.

Genéricas:
• Habilidad para buscar y analizar
• información proveniente de fuentes diversas.
• Capacidad de análisis y síntesis
• Habilidad en el manejo de equipo de cómputo
• Capacidad para trabajar en equipo.
• Capacidad de aplicar los conocimientos en la práctica.
Recursividad practica elaborada.
En esta unidad pusimos aprueba muchos métodos los cual se los
mostrare mas adelante

Paso 1.- primero debemos de crear un proyecto y tres paquetes el primero será de
EntradaSalida, el segundo paquete se llamara MetodoRecursivos y por ultimo
Tema2Recursividad este será nuestro ejecutable

Paso 2.- cada paquete tendrá sub clases.

• Paquete 1: clase llamada “Tools”
• Paquete 2: clases llamada.- Recursividad,
• Paquete 3: clase llamada “tema2recursividad” es el ejecutable o la clase
main.
Clases

TOOLS:
package EntradaSalida;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class Tools {
public static int leerInt(String msje) {
int num = 0;
boolean r = true;
do {
try {
num = (Integer.parseInt(JOptionPane.showInputDialog(null, msje, "dame
un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, no vacios ni use decimales o
letras");
}
} while (r);
return num;
}
public static double leerDouble(String msje) {
double num = 0;
boolean r = true;
do {
try {
 num = (Double.parseDouble(JOptionPane.showInputDialog(null, msje,
"dame un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, no espacios vacios ni use
letras");
}
} while (r);
return num;
}
public static float leerFloat(String msje) {
float num = 0;
boolean r = true;
do {
try {
num = (Float.parseFloat(JOptionPane.showInputDialog(null, msje, "dame
un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, espacios vacios ni use
letras");
}
} while (r);
return num;
}
public static Byte leerByte(String msje) {
byte num = 0;
boolean r = true;
do {
try {
 num = (Byte.parseByte(JOptionPane.showInputDialog(null, msje, "dame
un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, espacios vacios ni use
decimales o letras");
}
} while (r);
return num;
}
// Les recuerdo que udes deben complementar las Entrada de datos de enteros y
reales..tipos de datos de java

public static char leerChar(String msje) {// lectura de un caracter

return (JOptionPane.showInputDialog(null, msje).charAt(0));
}

public static String leerString(String msje) { //Lectura de una cadena

return (JOptionPane.showInputDialog(null, msje));
}

public static String leerName(String msje) { // lectura de un nombre con validacion

String cad;
do {
cad = JOptionPane.showInputDialog(null, msje);
if (cad.matches("([a-z]|[A-Z]|\\s)+")) {
return cad;
} else {
JOptionPane.showMessageDialog(null, msje + " contiene caracteres no
validos");
 }
} while (!cad.matches("([a-z]|[A-Z]|\\s)+"));

return cad;
}
// Mensajes de salida
public static void imprimeMsje(String msje) { // Salida de mensaje
JOptionPane.showMessageDialog(null, msje, "salida",
JOptionPane.INFORMATION_MESSAGE);
}
public static void errorMsje(String msje) { // Salida de mensaje de error
JOptionPane.showMessageDialog(null, msje, "intenta de nuevo",
JOptionPane.ERROR_MESSAGE);
}

public static void imprimeAreaTexto(String cad) {//Salida en una area de texto con
scroll
JTextArea areaSalida = new JTextArea(10, 4);
JScrollPane scroller = new JScrollPane(areaSalida);
areaSalida.setText("\n" + cad);
JOptionPane.showMessageDialog(null, scroller, "SALIDA",
JOptionPane.INFORMATION_MESSAGE);
}
public static int SiNo() { // Botones se pueden usar en ciclos o en switch
return (JOptionPane.showConfirmDialog(null, "deseas continuar", "capturando
de objetos", JOptionPane.YES_NO_OPTION));
}
// Metodos que permiten seleccionar un dato especifico cuando el ejercicio indica
items a considerar. Modelo que les puede servir para crear nuevos metodos.
public static char genero(String msje) {
 Object[] valores = {'M', 'F'};
char res = (char) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.INFORMATION_MESSAGE, null, valores, valores[0]);
return (res);
}
public static String carrera(String msje) { //Metodo que permite seleccionar una
carrera, debera de agregar las carreras que oferta el Tec
Object valores[] = {"Ing. Sistemas Computacionales", "Ing. Quimica", "Ing.
Informatica, Ing. Industrial, Ing. Electronica"};
String res = (String) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.INFORMATION_MESSAGE, null, valores, valores[0]);
return res;
}
public static String color() {
Object valores[] = {"Verde", "Rojo", "Azul Metálico", "Negro", "Blanco"};
String res = (String) JOptionPane.showInputDialog(null, "Gama de Colores", "
Selecciona:", JOptionPane.QUESTION_MESSAGE, null, valores, valores[0]);
return (res);
}
public static int semestre(String msje) {
Object[] valores = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12};
int res = (int) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.QUESTION_MESSAGE, null, valores, valores[0]);
return (res);
}

public static String numctrl() {

String ctrl;
do {
ctrl = leerString("Ingresa tu numero de control");
 ctrl = ctrl.trim();
if (ctrl.matches("[0-9]{8}")) {
return ctrl;
} else {
Tools.errorMsje("Recuerda que el numero de control son de 8 digitos");
}
} while (!ctrl.matches("[0-9]{8}"));
return ctrl;
}
}

RECURSIVIDAD:

package MetodosRecursivos;

import EntradaSalida.Tools;

public class Recursividad {

TABLA DE MULTIPLICAR APLICANDO RECURSIVIDAD

public static String imprimedato(int i) {
if (i <= 10) {
return tablaMultiplicar(i, 1) + "\n" + imprimedato(i + 1);
} else {
return "";
}
}
public static String tablaMultiplicar(int dato, int c) {
if (c <= 10) {
 return dato + "x" + c + "=" + (dato * c) + "\n" + tablaMultiplicar(dato, c + 1);
}
return "";
}
INVERTIR UN NUMERO APLICANDO RECURSIVIDAD
public static int invierteNum(int numero) {
int resto, invertido = 0;
while (numero > 0) {
resto = numero % 10;
invertido = invertido * 10 + resto;
numero /= 10;
}
return (invertido);
}

public static String imprimeinvertido(int i) {

if (i <= 15) {
int dato = Tools.leerInt(i + ")dato entero: ");
return i + ".- [" + dato + "]==>" + numinvertido(dato, 0) + "\n" +
imprimeinvertido(i + 1);
} else {
return "";
}
}

public static int numinvertido(int numero, int invertido) {

int resto;
if (numero > 0) {
resto = numero % 10;
 return numinvertido(numero /= 10, invertido * 10 + resto);
}
return (invertido);
}
RAIZ ESCOGIENDO CUALQUIER NUMERO AL AZAR
public static String verArray(int a[], int i) {
if (i < a.length) {
int dato = (int) (Math.random());
return "i==>" + i + ".-[" + dato + "]==" + "\n" + verArray(a, i + 1);
} else {
return "";
}

public static String imprimeraiz(int i) {

if (i <= 15) {
int dato = (int) (Math.random() * (999 - 100 + 1) + 100);
//int dato=Tools.leerInt(i+")dato entero: ");
return i + ".- [" + dato + "]==>" + raiz(dato) + "\n" + imprimeraiz(i + 1);
} else {
return "";
}
}

public static int raiz(int i) {

if (i <= 9) {
return (i);
 } else {
return (raiz((i % 10) + raiz(i / 10)));
}
}
BUSQUEDA EN EL ARRAY
public static int busquedaSecuencialRecursivaL(int a[], int numero, int n, int j) {
if (j > n) {
Tools.imprimeMsje("No existe el dato");
} else {
if (a[j] == numero) {
Tools.imprimeMsje("Esta en la posicion: " + j);
} else {
return busquedaSecuencialRecursivaL(a, numero, n, j + 1);
}
}
return numero;
}
NUMEROS AMIGOS
public static int amigo(int num1, int i, int div) {
if (i < num1) {
if (num1 % i == 0) { // Si 'numero1'%'i' es igual a
div += i;
amigo(num1, i + 1, div);

}
return div;

} else {
 return num1;
}
}
FUNCION FIBONACCI
public static int funcionFibonacci(int num) {
if (num == 0 || num == 1) {
return num;
} else {
return funcionFibonacci(num - 1) + funcionFibonacci(num - 2);
}
}

public static String imprimeFibonacci(int i, int n) {

if (i <= n) {
return funcionFibonacci(i) + "\n" + imprimeFibonacci(i + 1, n);
} else {
return "";
}
}
METODO BURBUJA
public static String burbu1(int a[], int i) {
if (i < a.length) {
return "" + a[i] + burbu2(a, i, i + 1) + "\n" + burbu1(a, i + 1);
}
return "";
}
public static String burbu2(int a[], int i, int j) {
int aux;
 if (j < a.length - 1) {
if (a[j] > a[j + 1]) {
aux = a[j];
a[j] = a[j + 1];
a[j + 1] = aux;
}
}
return "";
}
METODO FACTORIAL
public static int factorial(int numero) {
int resultado;
if (numero != 1) {
resultado = factorial(numero - 1) * numero;
} else {
resultado = 1;
}
return resultado;
}
METODO TRIANGULO APLICANDO RECURSIVIDAD
public static String imprimeTriangulo(int c1) {
if (c1 >= 1) {
return " " + Triangulo(c1) + "\n" + imprimeTriangulo(c1 - 1);
}
return "";
}

public static String Triangulo(int c2) {

 if (c2 >= 1) {
return c2 + " " + Triangulo(c2 - 1);
}
return "";
}
NUMEROS BINARIOS APLICANDO RECURSIVIDAD
public static String imprimeBinario(int n) {
if (n < 0) {
Tools.errorMsje("error numero negativo");

}
return binario(n / 2) + "" + n % 2;
}

public static String binario(int n) {

if (n / 2 == 0) {
return "" + n; //it's 0 or 1
}
return binario(n / 2) + "" + n % 2; //n%2 will be 0 or 1

}
NUMEROS AMIGOS APLICANDO RECURSIVIDAD
public static boolean sonAmigos(int num1, int num2) {
boolean amigos;
if (num1 == sumaDivisores(num2)) {
amigos = num2 == sumaDivisores(num1) ? true : false;
} else {
amigos = false;
 }
return amigos;
}
SUMA DE DIVISORES APLICANDO RECURSIVIDAD
public static int sumaDivisores(int numero) {
int sumaDivisores = 0;

int i = 0;
if (i < numero) {
if (numero % i == 0) {
sumaDivisores += i;
}
}
return sumaDivisores;
}
static int sumar(int t[], int pos) {
if (pos < t.length) {
return t[pos] + sumar(t, pos + 1);
}
return 0;
}
}
RESULTADOS DE P RACT ICAS:
CONCLUSIONES.-
La recursividad es un concepto fundamental en matemáticas y en computación
Es una alternativa diferente para implementar estructuras de repetición, los
módulos se hacen llamadas recursivas se puede usar en todas las situaciones en
la cual la solución puede ser expresada como una secuencia de movimientos,
pasos o transformaciones gobernadas por un conjunto de reglas además como se
pudo notar la recursividad también se puede trabajar mediante pilas así como
también se menciono algunos algoritmos para utilizar la recursividad
REFERENCIAS:

https://es.slideshare.net/bennnylove/recursividad-42425470
“estructura de datos” Osvaldo Cairo Silvia Guardati tercera edición.
https://www.tutorialesprogramacionya.com/javaya/detalleconcepto.php?codigo=12
3&punto=&inicio=40#:~:text=En%20Java%20los%20m%C3%A9todos%20pueden,
nuevas%20variables%20locales%20y%20par%C3%A1metros.
http://puntocomnoesunlenguaje.blogspot.com/2012/04/recursividad-en-java.html