unidad 2 estructura de datos
DESCRIPTION
Informacion acerca de estructura de datos todas las unidades dentro de el acerca de los temas vistos dentro de la unidad 2 todo esto para una investigacion concreta :vTRANSCRIPT
Instituto Tecnológico Superior de Coatzacoalcos
Ingeniería en Sistemas Computacionales
Nombre del Alumno:
No. Control: 14082078 Semestre: 3 Grupo: B
PORTAFOLIO DE EVIDENCIAS
Estructura de datos
Contreras Rodríguez OctavioApellido Paterno Apellido Materno Nombre(s)
Nombre del Docente: Blanquet Escobar LandyApellido Paterno Apellido Materno Nombre(s)
INDICEIntroducción......................................................................................................................................3
OBJETIVO GENERAL DE CURSO:............................................................................................4
Temario:...........................................................................................................................................5
Unidad 2 Recursividad.................................................................................................................8
2.1 Definición..................................................................................................................................8
2.2 Procedimientos recursivos..................................................................................................9
2.3 Ejemplos de casos recursivos..........................................................................................14
Conclusión.......................................................................................................................................15
Bibliografía....................................................................................................................................16
IntroducciónLa recursividad es una técnica muy utilizada en programación. Se suele utilizar para resolver problemas cuya solución se puede hallar resolviendo el mismo problema, pero para un caso de tamaño menor.
Los métodos recursivos se pueden usar en cualquier situación en la que la solución
pueda ser expresada como una sucesión de pasos o transformaciones gobernadas
por un conjunto de reglas claramente definidas.
En un algoritmo recursivo podemos distinguir dos partes:
Base o problema trivial que se puede resolver sin cálculo
Recursión: Fórmula da la solución del problema en función define de un problema del
mismo tipo más sencillo
OBJETIVO GENERAL DE CURSO:Identificar, seleccionar y aplicar eficientemente tipos de datos abstractos, métodos de ordenamiento y búsqueda para la optimización del rendimiento de soluciones de problemas del mundo real.
Temario:UNIDAD 1 Introducción a las estructuras de datos. 1.1 Tipos de datos abstractos (TDA). 1.2 Modularidad. 1.3 Uso de TDA. 1.4 Manejo de memoria estática. 1.5 Manejo de memoria dinámica UNIDAD 2 Recursividad 2.1 Definición 2.2 Procedimientos recursivos 2.3 Ejemplos de casos recursivos UNIDAD 3 Estructuras lineales 3.1Listas 3.1.1Operaciones básicas con listas. 3.1.2Tipos de listas. 3.13Listas simplemente enlazadas. 3.1.4Listas doblemente enlazadas. 3.1.5Listas circulares. 3.1.6Aplicaciones. 3.2Pilas. 3.2.1Representación en memoria estática y dinámica. 3.2.2Operaciones básicas con pilas. 3.2.3Aplicaciones. 3.2.4Notación infija y postfija. 3.2.5Recursividad con ayuda de pilas. 3.3Colas. 3.3.1Representación en memoria estática y dinámica. 3.3.2Operaciones básicas con colas. 3.3.3Tipos de colas: Cola simple, Cola circular y Colas dobles. Hernández
3.3.4Aplicaciones: Colas de prioridad. UNIDAD 4 Estructuras no lineales 4.1 Arboles. 4.1.1 Concepto de árbol. 4.1.2 Clasificación de árboles. 4.1.3 Operaciones básicas sobre árboles binarios. 4.1.4 Aplicaciones. 4.1.5 Arboles balanceados (AVL). 4.2 Grafos. 4.2.1 Terminología de grafos. 4.2.2 Operaciones básicas sobre grafos. UNIDAD 5 Métodos de ordenamiento 5.1 Algoritmos de Ordenamiento Internos 5.1.1 Burbuja. 5.1.2 Quicksort. 5.1.3 ShellSort. 5.1.4 Radix 5.2 Algoritmos de ordenamiento Externos 5.2.1 Intercalación 5.2.2 Mezcla Directa 5.2.3 Mezcla Natural UNIDAD 6 Métodos de búsqueda 6.1 Búsqueda secuencial 6.2 Búsqueda binaria 6.3 Búsqueda por funciones de HASH UNIDAD 7 Análisis de los algoritmos 7.1 Complejidad en el tiempo. 7.2 Complejidad en el espacio. 7.3 Eficiencia de los algoritmos.
Unidad 2
Recursividad
Unidad 2 Recursividad
2.1 Definición
Recursión es una técnica de programación en el cual un método puede llamarse a sí mismo. La recursión es muy interesante y una técnica efectiva en programación ya que puede producir algoritmos cortos y eficientes.
Algo es recursivo si se define en términos de sí mismo (cuando para definirse hace mención a sí mismo).
Si la invocación de un subprograma (función o subrutina) se produce desde el propio subprograma se dice que se trata de un subprograma recursivo.
Un método recursivo es un método, directa o indirectamente, se hace una llamada a sí mismo.
La recursión consiste en el uso de métodos recursivos.Se puede usar en toda situación, en la cual la solución puede ser expresada como una secuencia
de movimientos.
La función recursiva se compone de
- Caso base: Una solución simple para caso particular (puede haber más de un caso base). Es una instancia que se puede resolver sin recursión.
- Caso recursivo: Una solución que involucra a utilizar la misma función original, con parámetros que se acercan más al caso base.
Los pasos que sigue el caso recursivo son:
- El procedimiento se llama a sí mismo.- El problema se resuelve tratando el mismo problema pero de tamaño
menor.
1.1 Un ejemplo de la recursividad
- La manera en la cual el tamaño del problema disminuye asegura que el caso base eventualmente se alcanzara.
2.2 Procedimientos recursivosUn Procedimiento recursivo es aquel que se llama así mismo, solo que no regresa valor.
Cada método (función o procedimiento), tiene ciertas reglas, las cuales se mencionan a continuación:
La Función Recursiva Debe tener ciertos argumentos llamados valores base para que esta ya no se refiera a sí misma.
El Procedimiento Recursivo es donde Cada vez que la función se refiera a sí misma debe estar más cerca de los valores base.
Propiedades de procedimientos recursivos
Debe existir criterio base para que este se llame a sí mismo. Cada vez que el procedimiento se llame a si mismo debe estar más cerca del criterio base.
El Método De Las Tres Preguntas
Se usa para verificar si hay dentro de un programa funciones recursivas, se debe responder a 3 preguntas.
La pregunta caso base:¿Hay salida NO recursiva del procedimiento o función y la rutina funciona correctamente para este caso base?
La pregunta llamador más pequeño¿Cada llamada al procedimiento o función se refiere a un caso más pequeño del problema original?
La pregunta caso generalSuponiendo que las llamadas recursivas funcionan correctamente ¿funciona correctamente todo el procedimiento o función?
Escritura de procedimiento y funciones recursivas (pasos a seguir para hacer programas recursivos).
Recursividad
Se puede utilizar el siguiente método para escribir cualquier rutina recursiva.
Primero obtener una función exacta del problema a resolver.
A continuación, determinar el tamaño del problema completo que hay que resolver, este tamaño determina los valores de los parámetros en la llamada inicial al procedimiento o función.
Resolver el caso base en el que el problema puede expresarse no recursivamente, esto asegura una respuesta afirmativa a la pregunta base.
Por último, resolver el caso general correctamente en términos de un caso más pequeño del mismo problema, es decir una respuesta afirmativa a las preguntas 2 y 3 del método de las 3 preguntas.
Un ejemplo de caso recursivo es la sucesión de Fibonacci
Es la siguiente sucesión infinita de números naturales:
Esta sucesión la podemos representar de esta manera en java, aplicando la recursividad
Una vez ejecutado nos quedara de esta manera el código, en este programa necesitamos el Fibonacci de un número ingresado desde la línea de código.
1.2 Ejemplo de Fibonacci en caso recursivo (código en java).
1.3 Fibonacci en java ejecutado
A continuación presentamos el código:
package fibonaccirecursivo;
public class FibonacciRecursivo {
public static void main(String[] args) {
long num=5;
System.out.println("Serie Fibonacci");
System.out.println("El Fibonacci es "+fibo(num));
}
public static long fibo (long num){
if (num==0 || num==1){
return num;
}
else{
return fibo(num-1)+fibo(num-2);
}
}
}
Otro ejemplo el de las torres de Hanói
El de torres de Hanói primero presentamos el algoritmo de cómo funciona la sucesión
Entrada: Tres pilas de números origen, auxiliar, destino, con la pila origen ordenada
Salida: La pila destino
1. si origen entonces
1. mover el disco 1 de pila origen a la pila destino (insertarlo arriba de la pila
destino)
2. terminar
2. si no
1. hanoi( ,origen,destino, auxiliar) //mover todas las fichas menos la
más grande (n) a la varilla auxiliar
3. mover disco n a destino //mover la ficha grande hasta la varilla final
4. hanoi (auxiliar, origen, destino) //mover todas las fichas restantes, 1...n–1,
encima de la ficha grande (n)
5. terminar
Ahora en java…
Una vez escrito el programa procedemos a la ejecución
1.4 Programa en java de torres de Hanói
El código del programa
package hanoi;
import java.util.*;
public class Hanoi {
public void Hanoi(int num, int inicio,int temp, int fin)
{
if(num == 1)
{
System.out.print("Moviendo de la torre 1,ala torre 3");
}
else
{
Hanoi(num-1, inicio, fin,temp);
1.5 Ejecución de las torres de Hanói en java
System.out.println("Moviendose de la torre de inicio"+inicio+"ala torre final"+fin);
Hanoi(num-1, temp,inicio,fin);
}
}
}
Programa principal
package hanoi;
import java.util.Scanner;
public class Principal extends Hanoi{
public static void main(String[] args) {
int n=0;
Scanner leer = new Scanner(System.in);
Hanoi h = new Hanoi();
System.out.println("Ingrese el numero de aros");
n = leer.nextInt();
h.Hanoi(n, 1,2,3);
}
}
2.3 Ejemplos de casos recursivos Ejemplo: Factorial
Escribe un programa que calcule el factorial (!) de un entero no negativo.
1!= 1
2!= 2 2+1
3!= 6 3*2*1
4!= 24 4*3*2*1
5!= 120 5*4*3*2*1
Solucion recursiva
Aquí podemos ver la secuencia que toma el factorial.
N! si N = 0 (base)
(N-1) !* N>0 (recursión)
Un razonamiento recursivo tiene dos partes: la base y la regla recursiva de la construcción. La base no recursiva y es el punto tanto de partida como de determinación de la definición.
¿Cómo funciona la recursividad?
Si (n>0) Entonces ------- f(n)=1;
Else
Si(n>0) Entonces--------- N*f(n-1);
F(4)= ¿ = 24
F(4)= 4*6
F(3)= 3*2
F(2)= 2*1
F(1)= 1+1
1
ConclusiónEn esta unidad aprendimos detalladamente que es la recursividad y su aplicación en un programa de java para poder ejecutarlo. Recursión es una técnica de programación en el cual un método puede llamarse a sí mismo. La recursión es muy interesante y una técnica efectiva en programación ya que puede producir algoritmos cortos y eficientes.
Bibliografíahttps://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci
https://sites.google.com/site/estdatjiq/home/unidad-ii
http://itpn.mx/recursosisc/3semestre/estructuradedatos/Unidad%20II.pdf
https://es.wikipedia.org/wiki/Torres_de_Han%C3%B3i
http://puntocomnoesunlenguaje.blogspot.mx/2012/04/torres-de-hanoi.html