INSTITUTO TECNOLOGICO DE CANCUN

SISTEMAS COMPUTACIONALES

MATERIA: ESTRUCTURA DE DATOS

PROFESOR: LIC. LUIS MORENO LAILSON

INTEGRANTES DEL EQUIPO:

 GÓMEZ ROBLEDO GABRIELA
 SARRAGOT PASTRANA WILIAM ADRIEN
 ANGELES SANCHEZ DIEGO
 PECH SANCHEZ DANETSY AMELGA
 MATA GUTIÉRREZ JUAN CARLOS

5to SEMESTRE & EQUIPO #5

SEMTIEMBRE/2020
INDICE
INTRODUCCIÓN......................................................................................................................................1
2.1 RECURSIVIDAD DEFINICIÓN........................................................................................................2
2.2 PROCEDIMIENTOS RECURSIVOS...........................................................................................3
2.3 EJEMPLOS DE CASOS RECURSIVOS................................................................................4
CONCLUSIONES...................................................................................................................................12
BIBLIOGRAFÍA ..........................................................................................................................................14
INTRODUCCIÓN

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 DEFINICIÓN
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 sí 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.

Es posible escribir programas recursivos que generen

procesos que no dejan llamadas en espera. A estos procesos los llamamos procesos

3
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 evalúa 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.

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 ,... ,

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

5
2. Función factorial: 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; }

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

6
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.

Con 4 discos, es necesario 15 pasos.

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

El programa está preparado para 4 discos y este será el resultado.

8
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.

Programado en Python 2.7

1 def busquedaBinaria(unaLista, item):

2 primero = 0

3 ultimo = len(unaLista)-1

4 encontrado = False

9
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).

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

10
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.

11
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 sí 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 dice 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.

ANGELES SANCHEZ DIEGO

Lo abordado en esta segunda unidad es sobre conocer sobre la recursividad tanto su

definición y el cómo utilizarlo, en cuanto a lo abordado con anterioridad, nos da a
conocer sobre la recursividad la cual es una función a la que se llama a sí misma, de

12
forma que no tengamos que recurrir a usar bucles o ciclos haciendo el código más
eficiente y ahorrándonos pasos. En la investigación nos informa sobre sus
procedimientos los cuales deben llevarse a cabo para tener un procedimiento de
recursividad correcto, también habla sobre sus características las cuales son el de
poder subdividir un problema complejo en partes cada vez más sencillas, debe llegar a
un fin para cumplir con un propósito y debe tener valores base para que cada vez que
la función se refiera a sí mismo, el argumento de la función debe acercarse más al
valor base. De igual forma sabemos que existen tipos de recursividad los cuales son
directa e indirectas, en las directas es cuando una función, procedimiento o método se
invoca a sí misma, a el proceso se le denomina recursión directa y en la indirecta es
cuando invoca a una segunda función que esta a su vez invoca a la primera, a este
proceso se le denomina recursión indirecta. Se mostraron ejemplos de casos de
recursividad los cueles fueron la secuencia de Fibonacci, función factorial, torres de
Hanói y la búsqueda binaria. Me intereso mucho la secuencia de Fibonacci aunque
solamente es la suma de los anteriores pero si su fin es un número realmente extenso
el resultado lo será aún más, aunque la más espectacular seria las torres de Hanói
porque con el uso de la recursividad podemos conocer la solución del problemas sin
importan la cantidad de aros que tenga el problema en cuestión. Al final la unidad dos
es muy corta puesto que solo cuenta con tres temas pero son esenciales para el
entendimiento de la materia, y con la ayuda de la recursividad podemos generar
códigos más eficientes.

13
Gabriela Gómez Robledo

En esta unidad veremos la recursividad, su definición, como implementar, sus

funciones la recesividad es un tema muy importante en programación ya que se utiliza
muy frecuentemente y para perder implementar la recesividad primero tenemos que
tener en cuenta los más básico de ella, la importancia de esta en estructura de datos,
ejemplos, sus procedimientos, como se implemente la recursividad.

La recursividad es una técnica de programación que se utiliza para realizar una llamada
a una función desde ella misma. En esta investigación pudimos saber que tenemos dos
tipos de recursividad ya sea directa o indirecta, la directa se llama así misma, mientras
que la indirecta cuando una función puede invocar a una segunda función que a su vez
invoca a la primera, como también podemos descubrir que tiene dos componentes, el
caso base que es el resultado más simple, lo que conoce la función.

El segundo, el paso de recursión problema poco menos complejo que el original.

También puede incluir la palabra reservada return. El ejemplo más utilizado por su fácil
comprensión es el cálculo de números factoriales. Es una alternativa diferente para
implementar estructuras de repetición (ciclos). Los módulos se hacen llamadas
recursivas. La asignación de memoria, sea estática o dinámica, en realidad se tendrá
que aplicar en cualquier programa al momento de su codificación; tomando en cuenta
que cada programador tiene su estilo de programar

14
BIBLIOGRAFÍA

(s.f.). Obtenido de http://itpn.mx/recursosisc/3semestre/estructuradedatos/Unidad%20II.pdf

(s.f.). Obtenido de http://decsai.ugr.es/~jfv/ed1/c/cdrom/cap6/cap66.htm

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

Net Mentor (2020)Obtenido de https://www.netmentor.es/Entrada/Recursividad-programacion

https://es.wikipedia.org/wiki/Recursión_(ciencias_de_computación)#Factorial

http://di002.edv.uniovi.es/~jotero/16122004/recursividad.pdf

José Luis (2017)Obtenido de https://platzi.com/blog/ejemplo-de-recursividad-torres-de-hanoi/

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

https://runestone.academy/runestone/static/pythoned/SortSearch/LaBusquedaBinaria.html

15