Ingeniera En Sistemas Computacionales

Estructura De Datos
Catedrático: Luis Moreno Lailson.
Integrantes:
● Gómez Robledo Gabriela
● Sarragot Pastrana Wiliam Adrien
● Ángeles Sánchez Diego
● Pech Sanchez Danetsy Amelga
● Mata Gutiérrez Juan Carlos
5to Semestre y Equipo #5

Septiembre/2020

0
Contenido
INTRODUCCION.................................................................................................................................................1
2.1 RECURSIVIDAD DEFINICION...................................................................................................................2
2.2 PROCEDIMIENTOS RECURSIVOS......................................................................................................3
2.3 EJEMPLOS DE CASOS RECURSIVOS...........................................................................................5
CONCLUSIONES................................................................................................................................................7
B IBLIOGRAFÍA.........................................................................................................................................................14

0
INTRODUCCION

En esta corta unidad se estudiarán los temas relacionados a la recursión, para una mejor
comprensión se dará una definición satisfactoria y se procederá a explicar los tipos de
recursión, seguido de algunos ejemplos en los cuales se aplica la misma, se espera que al
finalizar el documento, el lector se lleve consigo una clara idea de la funcionalidad y el
funcionamiento de la recursividad aplicada en la estructura de datos.

1
2.1 RECURSIVIDAD DEFINICION

En matemáticas se da el nombre de recursión a la técnica consistente en definir una función

en términos de sí misma. Puesto que en C una función puede llamar a otras funciones, se
permite que una función también pueda llamarse a sí misma.

Cuando creamos un método recursivo debemos tener en cuenta que este tiene que terminar
por lo que dentro del método debemos asegurarnos de que no se está llamando a si mismo
todo el rato, Lo que quiere decir que el ciclo es finito.

Debemos tener mucho cuidado cuando realizamos llamadas recursivas ya que si la

utilizamos sin control podríamos desbordar la memoria del ordenador, causando que el
programa se rompa.

Un problema que pueda ser definido en función de su tamaño, sea este N, pueda ser

dividido en instancias más pequeñas (< N) del mismo problema y se conozca la solución

explícita a las instancias más simples, lo que se conoce como casos base, se puede

aplicar inducción sobre las llamadas más pequeñas y suponer que estas quedan

resueltas.

La memoria de un ordenador se divide en 4 segmentos:

 Segmento de código: almacena las instrucciones del programa en código máquina.

 Segmento de datos: almacena las variables estáticas o constantes.
 Montículo: almacena las variables dinámicas
 Pila del programa: Parte destinada a las variables locales y parámetros de la función
que se está ejecutando.

Cuando llamamos a una función (o método) el proceso es el siguiente:

 Se reserva espacio en la pila para los parámetros de la función y sus variables locales.
 Se guarda en la pila la dirección de la línea del código desde donde se ha llamado al
método.
 Se almacenan los parámetros de la función y sus valores en la pila.

2
  Finalmente se libera la memora asignada en la pila cuando la función termina y se
vuelve a la llamada de código original.

En cambio, cuando la función es recursiva:

 Cada llamada genera una nueva llamada a una función con los correspondientes
objetos locales.
 Volviéndose a ejecutar completamente, hasta la llamada a si misma. Donde vuelve a
crear en la pila los nuevos parámetros y variables locales. Tantos como llamadas
recursivas generemos.
 Al terminar, se van liberando la memoria en la pila, empezando desde la última función
creada hasta la primera, la cual será la última en liberarse.

2.2 PROCEDIMIENTOS RECURSIVOS

Un 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

1. Debe existir criterio base para que este se llame

a sí mismo.
2. Cada vez que el procedimiento se llame a si
mismo debe estar más cerca del criterio base.

3
Es posible escribir programas recursivos que generen procesos que no dejan llamadas en
espera. A estos procesos los llamamos procesos iterativos, en contraposición con los
procesos recursivos que generan los programas vistos hasta ahora.

En general, las versiones iterativas son menos elegantes y más difíciles de entender que las
recursivas, pero son más eficientes.

En otros lenguajes de programación existen bucles (for, while) para definir procesos
iterativos. En un lenguaje funcional puro no existen bucles. Se utiliza uno o más parámetros
auxiliares y se modifica su valor en cada llamada a la recursión.

Esta recursión que no deja llamadas en espera también recibe el nombre de tail recursión o
recursión por la cola. El código del intérprete que evalua la recursión por la cola puede tratar
estas llamadas de una forma especial, sabiendo que no hay que devolver el resultado para
que vuelva a ser procesado. Se devuelve el último valor a la llamada original y se puede
eliminar la pila de la llamada.

4
2.3 EJEMPLOS DE CASOS RECURSIVOS

Procedimientos Recursivos

1) Secuencia Fibonacci

2) Función Factorial

3) Torres de Hanoi

4) Búsqueda Binaria

1. Secuencia Fibonacci:

La secuencia de Fibonacci es aquella secuencia de enteros donde cada elemento

es la suma de los dos anteriores.

0 1 2 3 4 5 6 7 8 ..... <--- fib

0,1 ,1 ,2 ,3 ,5 ,8 ,13 ,21 ,... ,

5
Esto genera un proceso recursivo en forma de árbol, como se comprueba en la siguiente
figura, extraída del Abelson & Sussman:

2. Funcion Factorial:
6
Un factorial es el productorio de k, siendo k=1 hasta n siendo n números enteros.

Un productorio es una notación matemática (una representación) de la multiplicación de una

cantidad arbitraria.

Posteriormente se muestra nuevamente el problema de la resolución de la factorial.

using namespace std; int factorial(int x) :

if (x==0) return 1;

else return x*factorial(x−1); }

main() { int a=factorial(3);

La función anterior podría haberse escrito sin utilizar la recursividad, en forma iterativa,
del siguiente modo:
int factorial(int x)
{ int f=1;
for (int i=2;i<x;i++)
f=f*x;
return f; }

7
Las dos funciones realizan el mismo cálculo utilizando las mismas operaciones, pero la forma
recursiva emplea mayor cantidad de memoria (el paso del parámetro es por valor) y además
existe el coste añadido ˜ de las sucesivas llamadas, las cuales conllevan un determinado
tiempo
de procesador. En general una función no es recursiva o iterativa intrínsecamente: para cada
función recursiva existe una función iterativa con su misma especificación, y viceversa. Es
frecuente codificar de forma recursiva una función cuando su versión iterativa es muy
compleja.

3. Las torres de Hanói

Se trata de un rompecabezas, propuesto por el matemático Eduardo Lucas, un juego que
consiste en tres varillas verticales y una de las varillas tiene un indeterminado número de
discos apilados de forma decreciente, de abajo hacia arriba. El objetivo es trasladar todos
estos discos a una de las varillas verticales que está vacía. La varilla central se usa de apoyo
para trasladar los discos y se tiene que hacer conforme a unas reglas:

Se puede mover un solo disco a la vez.

Un disco de mayor tamaño no puede estar sobre un disco más pequeño.
Solo se puede desplazar el disco que esté más arriba en cada varilla.
De esto se puede deducir que según el número de discos que haya en la torre, se podrá
resolver el problema con un número de pasos mínimo que corresponde con la siguiente
relación:
Con 1 disco, es necesario 1 paso.
Con 2 discos, es necesario 3 pasos.
Con 3 discos, es necesario 7 pasos.

8
Con 4 discos, es necesario 15 pasos.

Esto se puede hacer con la fórmula P(n) = 2^n - 1. Siendo P(n) la función y n el número de
discos (se lee 2 elevado a n, es decir, 2 multiplicado por 2, n veces, menos 1).

Un ejemplo que resuelva el problema de Las Torres de Hanói con 4 discos.

Programado en java Scrip

9
El programa está preparado para 4 discos y este sería el resultado:

4. Búsqueda Binaria

En una búsqueda binaria se puede empezar desde el dato de en medio de una lista ordenara
para determinar si el ítem que buscamos se encuentra en la repasada central que dimos si
encontramos ese ítem, hemos terminado. Si no es el ítem correcto, podemos utilizar la
naturaleza ordenada de la lista para eliminar la mitad de los ítems restantes. Si el ítem que
buscamos es mayor que el ítem central, sabemos que toda la mitad inferior de la lista, así
como el ítem central, se pueden ignorar de la consideración posterior. El ítem, si es que está
en la lista, debe estar en la mitad superior.

10
 Programado en Python 2.7
1 def busquedaBinaria(unaLista, item):
2 primero = 0
3 ultimo = len(unaLista)-1
4 encontrado = False
5
6 while primero<=ultimo and not encontrado:
7 puntoMedio = (primero + ultimo)//2
8 if unaLista[puntoMedio] == item:
9 encontrado = True
10 else:
11 if item < unaLista[puntoMedio]:
12 ultimo = puntoMedio-1
13 else:
14 primero = puntoMedio+1
15
16 return encontrado
17
18 listaPrueba = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
19 print(busquedaBinaria(listaPrueba, 3))
20 print(busquedaBinaria(listaPrueba, 13))

Cuando dividimos la lista suficientes veces, terminamos con una lista que tiene un único
ítem. Ya sea aquél ítem único el valor que estamos buscando o no lo sea. En todo caso,
habremos terminado.

El número de comparaciones necesarias para llegar a este punto es i donde n2^i=1. La

solución para i nos da i=logN. El número máximo de comparaciones es logarítmico con
respecto al número de ítems de la lista. Por lo tanto, la búsqueda binaria es O(logn).

11
En el análisis que hicimos arriba se asumió que el operador de partición requiere un tiempo
constante. Sin embargo, sabemos que el operador de partición en Python es realmente O(k).
Esto significa que la búsqueda binaria utilizando la partición no funcionará estrictamente en
tiempo logarítmico. Por suerte esto se puede remediar pasando la lista junto con los índices
de inicio y final.
A pesar de que una búsqueda binaria es generalmente mejor que una búsqueda secuencial,
es importante tener en cuenta que para valores pequeños de n, el costo adicional del
ordenamiento probablemente no vale la pena. De hecho, siempre debemos considerar si es
rentable asumir el trabajo extra del ordenamiento para obtener beneficios en la búsqueda. Si
podemos ordenar una sola vez y luego buscar muchas veces, el costo del ordenamiento no
es tan significativo. Sin embargo, para listas grandes, incluso ordenar una vez puede resultar
tan costoso que simplemente realizar una búsqueda secuencial desde el principio podría ser
la mejor opción.

12
CONCLUSIONES

WILLIAM ADRIEN SARRAGOT PASTRANA

En esta unidad 2 aprenderemos detalladamente lo que funciona recursividad y como se
aplica en un programa de la vida real para poderlo ejecutar en una computadora mediante un
programa de java. Sabemos que recursividad es el método directa o indirectamente ya que
se llama a si mismo para tener la mención de sí mismo. En la investigación nos da a conocer
los procedimientos que debe llevarse a cabo para tener un procedimiento recursivo correcto,
nos doce que procedimiento recursivo es todo aquel que se llama a sí mismo, solo que no
regresa su valor. Cuenta con unas cierta reglas las cuales tienes que seguir debes tener
algunos ciertos argumentos llamado en los valores baso que tú le des ya que no se refiere a
sí misma y otra podría ser donde cada vez que la función se refiera a si misma debe estar
más cerca de los valores bases y si nosotros queremos saber si está bien el método que
hicimos de recursividad se hacen 3 preguntas para saber si el método que estas aplicando
es el correcto. ¿Hay salida no recursiva del procedimiento o función y la rutina correcta para
este caso base? ¿Cada llamada al procedimiento o función se refiere a un caso más
pequeño del problema original? ¿Funciona correctamente todo el procedimiento o función?
Sabemos que la unidad 2 es muy corta los temas que se tienen que estudiar más que nada
es comprender su definición y poder llevar acabo los tipos de recursión que existen en la vida
cotidiana y en un programa de java. Me llamo mucho la atención lo que decía Eduardo como
explicaba el método de torres de Hanói que decía que consistía de 3 variarlas verticales y
una de las varillas tiene un determinando número de discos apilados de una forma
decreciente, de abajo hacia arriba y todo con la finalidad para trasladar los discos que se
obtienen con unas ciertas reglas.

13
BIBLIOGRAFÍA
(s.f.). Obtenido de [Link]

(s.f.). Obtenido de [Link]

Gutiérrez, G. M. (2013). TMP. Obtenido de Tutorial de programacion multiplataforma.

Net Mentor (2020)Obtenido de [Link]

[Link]

[Link]

José Luis (2017)Obtenido de [Link]

Solución de problemas de algoritmos y estructuras de datos Obtenido de

[Link]

14
15