Métodos de Búsqueda y Recursividad en

Programación
Erick
7 de octubre de 2025

1
Índice
1. Introducción 3

2. Métodos de búsqueda 3
2.1. Definición general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2. Búsqueda lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3. Búsqueda binaria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3.1. Búsqueda binaria iterativa . . . . . . . . . . . . . . . . . . . . . . . 5
2.3.2. Búsqueda binaria recursiva . . . . . . . . . . . . . . . . . . . . . . . 6

3. Recursividad 7
3.1. Definición general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2. Recursividad frente a iteraciones . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3. Tipos de recursividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.4.1. Factorial de un número (recursión directa) . . . . . . . . . . . . . . 8
3.4.2. Serie de Fibonacci (recursión directa) . . . . . . . . . . . . . . . . . 8

4. Ejercicios propuestos 9
4.1. Métodos de búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2. Recursividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5. Conclusiones 10

6. Referencias 10

2
1. Introducción
En programación, los métodos de búsqueda son fundamentales para localizar informa-
ción especı́fica dentro de estructuras de datos, ya sea en arreglos, listas o bases de datos.
La eficiencia en la búsqueda no solo mejora el rendimiento del programa, sino que también
optimiza el uso de recursos computacionales, especialmente cuando se trabaja con grandes
volúmenes de datos. Entre los métodos más conocidos se encuentran la búsqueda lineal,
sencilla pero menos eficiente, y la búsqueda binaria, que aprovecha el orden de los datos
para reducir significativamente el número de comparaciones necesarias.
Por otro lado, la recursividad es una técnica de programación que permite que una
función se llame a sı́ misma para resolver problemas complejos dividiéndolos en subpro-
blemas más pequeños y manejables. Esta estrategia es especialmente útil en algoritmos
de búsqueda y ordenamiento, ya que facilita la implementación de soluciones elegantes y
estructuradas, aunque requiere un manejo cuidadoso de los casos base y de la memoria
utilizada.
En conjunto, los métodos de búsqueda y la recursividad forman herramientas esen-
ciales para el desarrollo de programas eficientes y robustos, siendo pilares de la lógica
computacional y de la optimización de algoritmos en ingenierı́a de software.

2. Métodos de búsqueda
2.1. Definición general
Los métodos de búsqueda son algoritmos que permiten localizar un elemento especı́fico
dentro de una estructura de datos, como arreglos, listas o bases de datos. Su objetivo
principal es encontrar el valor buscado de manera eficiente, minimizando el tiempo y los
recursos necesarios. La elección del método de búsqueda adecuado depende del tamaño
de los datos, su organización y la frecuencia con la que se realizan búsquedas.

2.2. Búsqueda lineal

La búsqueda lineal consiste en revisar secuencialmente cada elemento de la estructura
de datos hasta encontrar el valor deseado o hasta recorrer todos los elementos. Es simple
de implementar, pero menos eficiente cuando los datos son numerosos.

Ejemplo en C++:

1 # include < iostream >

2 using namespace std ;
3

4 int busquedaLineal ( int arr [] , int n , int clave ) {

5 for ( int i = 0; i < n ; i ++) {
6 if ( arr [ i ] == clave ) {
7 return i ; // Retorna la posicion del
elemento
8 }
9 }
10 return -1; // Retorna -1 si no se encuentra
11 }

3
 12

13 int main () {
14 int numeros [] = {5 , 3 , 8 , 6 , 2};
15 int n = sizeof ( numeros ) / sizeof ( numeros [0]) ;
16 int clave = 6;
17 int resultado = busquedaLineal ( numeros , n , clave ) ;
18

19 if ( resultado != -1)
20 cout << " Elemento encontrado en la posicion : " <<
resultado << endl ;
21 else
22 cout << " Elemento no encontrado " << endl ;
23

24 return 0;
25 }

Explicación lı́nea a lı́nea:

1. #include <iostream>: Incluye la librerı́a estándar para entrada y salida de datos.

2. using namespace std;: Evita escribir std:: en cada uso de cout o cin.

3. int busquedaLineal(int arr[], int n, int clave): Función que recibe un arre-
glo, su tamaño y el valor a buscar.

4. for (int i = 0; i <n; i++): Recorre todos los elementos del arreglo.

5. if (arr[i] == clave): Compara el elemento actual con el valor buscado.

6. return i;: Retorna la posición si el elemento se encuentra.

7. return -1;: Retorna -1 si no se encuentra el valor en el arreglo.

8. int numeros[] = {5, 3, 8, 6, 2};: Declara e inicializa el arreglo de números.

9. int n = sizeof(numeros)/sizeof(numeros[0]);: Calcula la cantidad de elemen-

tos del arreglo.

10. int resultado = busquedaLineal(numeros, n, clave);: Llama a la función de

búsqueda y guarda el resultado.

11. cout (( ...: Muestra el resultado en pantalla.

2.3. Búsqueda binaria

La búsqueda binaria es más eficiente que la lineal, pero requiere que
el arreglo esté ordenado. El algoritmo compara el valor buscado con el
elemento del medio, descartando la mitad del arreglo en cada iteración.

4
2.3.1. Búsqueda binaria iterativa

Ejemplo en C++:
1 # include < iostream >
2 using namespace std ;
3

4 int b u s q u e d a B i n a r i a I t e r a t i v a ( int arr [] , int n , int

clave ) {
5 int inicio = 0 , fin = n - 1;
6

7 while ( inicio <= fin ) {

8 int medio = inicio + ( fin - inicio ) / 2;
9

10 if ( arr [ medio ] == clave )

11 return medio ;
12 else if ( arr [ medio ] < clave )
13 inicio = medio + 1;
14 else
15 fin = medio - 1;
16 }
17 return -1;
18 }
19

20 int main () {
21 int numeros [] = {2 , 3 , 5 , 6 , 8};
22 int n = sizeof ( numeros ) / sizeof ( numeros [0]) ;
23 int clave = 6;
24 int resultado = b u s q u e d a B i n a r i a I t e r a t i v a (
numeros , n , clave ) ;
25

26 if ( resultado != -1)
27 cout << " Elemento encontrado en la posicion : "
<< resultado << endl ;
28 else
29 cout << " Elemento no encontrado " << endl ;
30

31 return 0;
32 }

Explicación lı́nea a lı́nea:

a ) int inicio = 0, fin = n - 1;: Se definen los lı́mites del arreglo.

b ) while (inicio <= fin): Mientras no se haya reducido la búsqueda a
cero elementos.
c ) int medio = inicio + (fin - inicio)/2;: Calcula la posición del elemento
central.
d ) if (arr[medio] == clave): Si el elemento central es la clave, retorna
la posición.

5
 e ) else if (arr[medio] <clave): Si la clave es mayor, se descarta la
mitad inferior.
f ) else fin = medio - 1;: Si la clave es menor, se descarta la mitad
superior.

2.3.2. Búsqueda binaria recursiva

Ejemplo en C++:
1 # include < iostream >
2 using namespace std ;
3

4 int b u s q u e d a B i n a r i a R e c u r s i v a ( int arr [] , int inicio

, int fin , int clave ) {
5 if ( inicio > fin ) return -1; // Caso base : no
se encuentra
6

7 int medio = inicio + ( fin - inicio ) /2;

8

9 if ( arr [ medio ] == clave )

10 return medio ;
11 else if ( arr [ medio ] < clave )
12 return b u s q u e d a B i n a r i a R e c u r s i v a ( arr , medio +
1 , fin , clave ) ;
13 else
14 return b u s q u e d a B i n a r i a R e c u r s i v a ( arr , inicio ,
medio - 1 , clave ) ;
15 }
16

17 int main () {
18 int numeros [] = {2 , 3 , 5 , 6 , 8};
19 int n = sizeof ( numeros ) / sizeof ( numeros [0]) ;
20 int clave = 6;
21 int resultado = b u s q u e d a B i n a r i a R e c u r s i v a (
numeros , 0 , n -1 , clave ) ;
22

23 if ( resultado != -1)
24 cout << " Elemento encontrado en la posicion : "
<< resultado << endl ;
25 else
26 cout << " Elemento no encontrado " << endl ;
27

28 return 0;
29 }

Explicación lı́nea a lı́nea:

a ) if (inicio >fin) return -1;: Caso base: no se encuentra el elemento.

b ) int medio = inicio + (fin - inicio)/2;: Calcula el elemento central.

6
 c ) if (arr[medio] == clave) return medio;: Retorna si se encuentra la
clave.

d ) else if (arr[medio] <clave): Busca recursivamente en la mitad superior.

e ) else: Busca recursivamente en la mitad inferior.

3. Recursividad

3.1. Definición general

La recursividad es una técnica de programación mediante la cual una función
se llama a sı́ misma para resolver un problema. Este enfoque permite dividir
un problema complejo en subproblemas más peque~nos y manejables, hasta
llegar a un caso base, que es la condición que detiene la recursión.
La recursividad es fundamental en programación porque simplifica la implementació
de algoritmos como búsqueda en árboles, recorridos de grafos, cálculo
de factoriales o series matemáticas.

3.2. Recursividad frente a iteraciones

Tanto la recursividad como la iteración (ciclos for, while) permiten repetir
un conjunto de instrucciones, pero existen diferencias clave:

Caracterı́stica Recursión Iteración

Legibilidad Suele ser más clara y elegan-
Puede ser más compleja en
te problemas con muchos pa-
sos
Consumo de memoria Mayor, por las llamadas en Menor, usa variables locales
la pila sin apilar llamadas
Casos de uso Ideal para problemas que Ideal para repetición simple
se dividen en subproblemas y controlada
(divide y vencerás)
Facilidad de implementación Puede ser más corta y direc- Puede requerir más código
ta para manejar subproblemas
complejos

Cuadro 1: Comparación entre recursión e iteración

Conclusión: Se recomienda la recursión cuando la naturaleza del problema

es jerárquica o auto-similar, y la iteración cuando la repetición es lineal
y no requiere dividir el problema.

3.3. Tipos de recursividad

a ) Recursión directa: La función se llama a sı́ misma directamente. Ejemplo:
cálculo de factorial.

7
 b ) Recursión indirecta: La función A llama a la función B, que a su vez
llama a la función A.

c ) Recursión de cola (tail recursion): La llamada recursiva es la última

operación de la función, lo que permite optimización de memoria por
el compilador.

d ) Recursión no de cola: La llamada recursiva no es la última operación,

por lo que mantiene estados en la pila.

3.4. Ejercicios
3.4.1. Factorial de un número (recursión directa)

1 # include < iostream >

2 using namespace std ;
3

4 int factorial ( int n ) {

5 if ( n == 0) return 1; // Caso base
6 return n * factorial ( n - 1) ; // Llamada
recursiva
7 }
8

9 int main () {
10 int num = 5;
11 cout << " Factorial de " << num << " es : " <<
factorial ( num ) << endl ;
12 return 0;
13 }

Explicación lı́nea a lı́nea:

a ) if (n == 0) return 1;: Caso base que detiene la recursión (el factorial

de 0 es 1).

b ) return n * factorial(n - 1);: Multiplica el número actual por el factorial

del número anterior.

c ) int num = 5;: Variable que almacena el número para calcular su factorial.

d ) cout (( ...: Imprime el resultado del factorial en pantalla.

3.4.2. Serie de Fibonacci (recursión directa)

1 # include < iostream >

2 using namespace std ;
3

4 int fibonacci ( int n ) {

8
 5 if ( n == 0) return 0; // Caso base 1
6 if ( n == 1) return 1; // Caso base 2
7 return fibonacci ( n - 1) + fibonacci ( n - 2)
; // Llamadas recursivas
8 }
9

10 int main () {
11 int n = 10;
12 cout << " Serie de Fibonacci hasta el
termino " << n << " : " ;
13 for ( int i = 0; i < n ; i ++)
14 cout << fibonacci ( i ) << " " ;
15 cout << endl ;
16 return 0;
17 }

Explicación lı́nea a lı́nea:

1) if (n == 0) return 0; y if (n == 1) return 1;: Casos base que

detienen la recursión.

2) return fibonacci(n - 1) + fibonacci(n - 2);: Cada término es

la suma de los dos anteriores.

3) Ciclo for en main: Imprime la serie hasta el término n.

4. Ejercicios propuestos

4.1. Métodos de búsqueda

Ejercicio 1:
Dado el arreglo int arr[] = {12, 7, 9, 20, 15};, realiza una búsqueda
lineal para encontrar el número 20. Indica la posición donde se encuentra
y explica paso a paso cómo se realiza la búsqueda.
Ejercicio 2:
Dado el arreglo ordenado int arr[] = {3, 6, 9, 12, 15, 18, 21};, realiza
una búsqueda binaria (iterativa o recursiva) para encontrar el número
15. Explica cada paso y cómo se descartan mitades del arreglo.

4.2. Recursividad
Ejercicio 1:
Escribe un programa en C++ que calcule el factorial de un número ingresado
por el usuario usando recursión. Explica la función recursiva y el
caso base.

9
Ejercicio 2:
Realiza un programa en C++ que genere los primeros n términos de la
serie de Fibonacci usando recursión. Explica cómo cada término depende
de los dos anteriores y cómo se manejan los casos base.

5. Conclusiones
Al desarrollar esta guı́a aprendı́ que los métodos de búsqueda y la
recursividad son herramientas esenciales en programación para optimizar
la resolución de problemas. La búsqueda lineal, aunque sencilla, es
útil en datos no ordenados, mientras que la búsqueda binaria permite
localizar elementos de forma eficiente en arreglos ordenados.
La recursividad, por su parte, facilita la resolución de problemas
que se pueden dividir en subproblemas similares, como el cálculo de
factoriales o series matemáticas. Comprendı́ también la importancia
de definir correctamente los casos base para evitar bucles infinitos.
En problemas reales, estos métodos se aplican en diversas áreas:

Búsqueda de registros en bases de datos o archivos.

Optimización de algoritmos en software de gran escala.
Resolución de problemas matemáticos y cientı́ficos mediante algoritmos
recursivos.
Procesamiento de estructuras jerárquicas, como árboles y grafos
en sistemas de información.

En conclusión, dominar estas técnicas permite programar de forma más

eficiente, clara y profesional, aplicable en ingenierı́a de software
y desarrollo de aplicaciones.

6. Referencias
Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2022).
Introduction to Algorithms (4th ed.). MIT Press.
Lafore, R. (2020). Data Structures and Algorithms in C++ (2nd
ed.). Sams Publishing.
Sedgewick, R., & Wayne, K. (2021). Algorithms (4th ed.). Addison-Wesley
Goodrich, M. T., Tamassia, R., & Mount, D. M. (2022). Data Structures
and Algorithms in C++ (2nd ed.). Wiley.
Stroustrup, B. (2013). The C++ Programming Language (4th ed.).
Addison-Wesley.

10