ED Unidad 2: Recursividad, ordenamiento y búsqueda de datos

Estructuras de datos Carrera de Software
Ph.D. Franklin Parrales 1
31/10/2021
Recursividad,
ordenamiento y
búsqueda de datos
Unidad 2
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Estructuras de Datos

31/10/2021
Objetivo general de la Unidad 2
Implementar rutinas recursivas y algoritmos de búsqueda /
ordenamiento de datos con objetos para la elaboración de
programas

31/10/2021
Contenido
• Algoritmos recursivos
– Recursión vs iteración
– Métodos recursivos
• Algoritmos de ordenamiento de datos
– Ordenación por BubleSort
– Ordenación por selección
– Ordenación por inserción
– Ordenación QuickSort
– Ordenamiento de objetos
• Algoritmos de búsqueda de datos.
– Búsqueda secuencial
– Búsqueda binaria

31/10/2021
Recursión
• La estrategia a seguir es la delegación de
tareas.
• Es decir que un problema grande se
subdivide en pequeñas tareas, y éstas se
delegan.
• Implica llamar al mismo procedimiento
varias veces.

31/10/2021
La Función Factorial
• La propiedad primordial del factorial es
que está relacionada a su anterior valor
n!=n*(n-1)!
static long factorial (int n){
long fact;
fact = 1;
for(int i = 1; i <=n; i++)
fact = fact * i;
return (fact);
}

31/10/2021
La Función Factorial
• La función factorial se define como:
n! = 1 si n=0
n*(n-1)! En otro caso
• Dicha definición es recursiva, porque n! está en
términos de (n-1)!, lo cual tiene la misma forma
del original.
• La implementación de la función en Java usando
recursión sería: static long factorial (int n){
if (n <= 1)
return 1;
else {
long resultado = n * factorial(n - 1);
return resultado;
}
}

31/10/2021
Manejo Interno de la Recursión
• En el proceso de encontrar la respuesta,
el computador va hacia los procesos
internos, que son las llamadas al mismo
procedimiento una y otra vez.
• Supongamos que se quiere evaluar
fact= Factorial(4);
• En el programa principal se hace la
primera llamada a la función.

31/10/2021
Primera llamada
main
Factorial
4
n if(n==0){
return(1);
} else{
return(n*Factorial(n-1));
}
?
La función llama a Factorial(n-1), y tan pronto
ésta regrese, se ejecuta la operación indicada

31/10/2021
Segunda llamada
main
Factorial
3
n if(n==0){
return(1);
} else{
}
?
Factorial
Igualmente al anterior caso, aquí se hace otro
llamado interno a la función, y la operación no se
realiza hasta que se retorne dicho valor

31/10/2021
Tercera llamada
main
Factorial
2
n if(n==0){
return(1);
} else{
}
?
Factorial
Siguiendo la lógica, se llama a Factorial(1), y éste a su vez
llama a Factorial(0), realizándose dos llamadas más a la
función
Factorial

31/10/2021
Última llamada
Factorial
0
n if(n==0){
return(1);
} else{
}
Factorial
Factorial
main
Factorial
Factorial
En este punto, la situación
varía, como n es 0, la función
retorna su resultado
inmediatamente
return(1);

31/10/2021
Retorno
Factorial
1
n if(n==0){
return(1);
} else{
}
Factorial
Factorial
Factorial
main
1
Desde este punto, se devuelve el retorno a cada
llamada recursiva
return(1*1);

31/10/2021
Retorno
main
Factorial
2
n if(n==0){
return(1);
} else{
}
1
Factorial
Factorial
return(2*1);

31/10/2021
Retorno
Factorial
3
n if(n==0){
return(1);
} else{
}
2
Factorial
main
return(3*2);

31/10/2021
Retorno
main
Factorial
4
n if(n==0){
return(1);
} else{
}
6
return(4*6);

31/10/2021
El Paradigma Recursivo
• Toda función recursiva tiene la siguiente
estructura:
if(Prueba para el caso simple){
return(solución simple sin usar recursión);
} else{
return(solución recursiva llamando a la misma función);
}

31/10/2021
Contenido

31/10/2021
Recursión vs iteración
• La recursividad (recursión) es aquella propiedad
que posee un método por la cual puede llamarse
a sí mismo.
• Normalmente, es menos eficiente en términos de
tiempo de computadora que una solución iterativa,
debido a las operaciones auxiliares que llevan
consigo las invocaciones suplementarias a los
métodos
• Sin embargo, en muchas circunstancias, el uso de
la recursión permite a los programadores
especificar soluciones naturales, sencillas, que
serían, en caso contrario, difíciles de resolver

31/10/2021
Ejemplo
• Dado un número natural n, obtener la
suma de los dígitos de que consta.
Presentar un algoritmo recursivo y otro
iterativo
• Se asume que el número es natural y que,
por tanto, no tiene signo. La suma de los
dígitos se puede expresar:
suma = suma(n/10) + modulo (n,10) para n > 9
suma = n para n ≤ 9, caso base
El caso base, el que se resuelve directamente, es n ≤ 9 y, a su vez, es la
condición de parada

31/10/2021
Solución recursiva
int sumaRecursiva(int n) {
if (n <= 9)
return n;
else
return sumaRecursiva(n/10) + n%10;
}

31/10/2021
Solución iterativa
• La solución iterativa se construye con un
bucle mientras, repitiendo la acumulación
del resto de dividir n por 10 y actualizando
n en el cociente.
• La condición de
salida del bucle es
que n sea menor o
igual que 9
int sumaIterativa(int n){
int suma = 0;
while (n > 9){
suma += n%10;
n /= 10;
}
return (suma+n);
}

31/10/2021
Contenido

31/10/2021
Métodos recursivos
• Un método recursivo es un método que se
invoca a sí mismo de forma directa o
indirecta.
– En recursión directa, el código del método f()
contiene una sentencia que invoca a f()
– En recursión indirecta, el método f() invoca a un
método g() que a su vez invoca al método p(), y
así sucesivamente hasta que se invoca de nuevo
al método f()
• Para que sea correcto, debe existir una
“forma de salir” de la secuencia de llamadas
recursivas

31/10/2021
Contenido

31/10/2021
Introducción
• Tres operaciones muy importantes en programación:
– ORDENACIÓN
– BÚSQUEDA
– MEZCLA
• La Ordenación consiste en
– Disponer un conjunto de datos en algún determinado orden con
respecto a uno de los campos del conjunto
– Una colección de datos puede ser almacenada en
• Un array
• Un archivo
• Un array de registros
• Una lista enlazada o un arbol
Ordenación
externa
Ordenación
interna

31/10/2021
Introducción
• El problema del ordenamiento puede
establecerse mediante la siguiente acción:
– Dados los elementos:
– Ordenar consiste en permutar esos
elementos en un orden tal que
dada una función de ordenamiento f:
n
k
k
k a
a
a ,
,
, 2
1

)
(
)
(
)
( 2
1 n
k
k
k a
f
a
f
a
f 

 
n
a
a
a ,
,
, 2
1 

31/10/2021
Introducción
• Normalmente, la función de ordenamiento no es
evaluada de acuerdo a una regla de computación
determinada, pero se guarda como un componente
explícito (campo) de cada item (elemento). El valor
de ese campo se llama la llave del item.
• Un método de ordenamiento es estable si el orden
relativo de elementos con igual llave permanece
inalterado por el proceso de ordenamiento.
• Se entiende que los métodos de ordenamiento
buscan un uso eficiente de la memoria por lo que las
permutaciones de elementos se hará in situ, es decir,
usando el mismo contenedor original.

31/10/2021
Introducción
• En lo que sigue se considera que la
estructura lineal (array, lista, vector o
secuencia) a ordenar se representa por un
array de objetos (números enteros):
int a[ ] = new int[MAX];
• siendo MAX el número máximo de
elementos del array. El orden de los
elementos después de la ordenación se
considera ascendente.

31/10/2021
Métodos
• Son numerosos
• Se miden de acuerdo a la eficiencia
– Se toman en cuenta dos criterios
• Tiempo menor de ejecución
• Menor número de instrucciones
• Hay dos grupos de métodos
– Directos
• Burbuja, Selección, Inserción
– Indirectos
• Shell, quicksort, mergesort, etc.

31/10/2021
Contenido

31/10/2021
Algoritmo burbuja
• Es un método caracterizado por la
comparación e intercambio de pares de
elementos hasta que todos los elementos
estén ordenados.
• En cada iteración se coloca el elemento
más pequeño (orden ascendente) en su
lugar correcto, cambiándose además la
posición de los demás elementos del
array.

31/10/2021
Burbuja (Bubble)
• Este método realiza comparaciones de
todas las posibles parejas de llaves
intercambiando aquellas que se encuentran
fuera de orden.
• Utiliza un proceso repetitivo comparando
las parejas de datos adyacentes del inicio
al final del arreglo donde, después de la
primer pasada la llave mayor queda en la
última posición del arreglo.

31/10/2021
Burbuja (Bubble)
Variables
• n es el total de elementos
• K arreglo de llaves
• t variable auxiliar para el intercambio
• i,j variables para los indices
Burbuja
Inicio
para i= n-1 ; i>0 ; i--
para j=0; i>j; j++
si (k[j] > k[j+1])
t = k[j];
k[j]= k[j+1];
k[j+1] = t;
Fin
3 8 2 1 4
0 1 2 3 4 5
2
K
3 8 2 1 4 2
3 2 8 1 4 2
3 2 1 8 4 2
3 2 1 4 8 2
3 2 1 4 2 8
Primera
pasada

31/10/2021
3 2 1 4 2 8
2 3 1 4 2 8
2 1 3 4 2 8
2 1 3 4 2 8
2 1 3 2 4 8
Segunda
pasada
2 1 3 2 4 8
1 2 3 2 4 8
1 2 3 2 4 8
1 2 2 3 4 8
Tercer
pasada
1 2 2 3 4 8
1 2 2 3 4 8
1 2 2 3 4 8
Cuarta
pasada
1 2 2 3 4 8
1 2 2 3 4 8
Quinta
pasada

31/10/2021
Ejemplo y análisis
• Es un algoritmo sencillo pero poco eficiente
– En la primera revisión, se efectúan n-1
comparaciones
– En la segunda, n-2…. y en la ultima, 1
comparacion
– En total se efectuaran ½(n2-n) comparaciones
– Es un algoritmo O(n2), es decir, es lento
23
19
45
6
19
23
Comparación No.
Revisión No.
1
1 2 3
6
45
2
6
23
3
6
19

31/10/2021
BUBBLESORT-resumen
• Este algoritmo
– Consiste en “revisar” varias veces la lista
– Para una lista de n elementos, se la revisara
n-1 veces
• En cada revisión i
– Se comparan los n-i elementos adyacentes
– Ubicando los mayores al final de la lista
– Y burbujeando los menores hacia el inicio de
la misma

31/10/2021
Algoritmo BubleSort
static void bubbleSort(int[] arr) {
int n = arr.length;
int temp = 0;
for(int i=0; i < n; i++){
for(int j=1; j < (n-i); j++){
if(arr[j-1] > arr[j]){
//swap elements
temp = arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}
}
}
public static void main(String[] args) {
int arr[] ={3,60,35,2,45,320,5};
System.out.println("Array Before Bubble Sort");
for(int i=0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
bubbleSort(arr);
//sorting array elements using bubble sort
System.out.println("Array After Bubble Sort");
for(int i=0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
Ejemplo de uso

31/10/2021
Contenido

31/10/2021
Algoritmo de selección
(Selection Sort)
• En éste método, en el i-ésimo paso
seleccionamos el elemento con la llave de
menor valor, entre a[i],…, a[n] y lo
intercambiamos con a[i].
• Como resultado, después de i pasadas, el
i-ésimo elemento menor ocupará a[1],…,
a[i] en el lugar ordenado.

31/10/2021
Algoritmo de selección
(Selection Sort)
• En una lista con n elementos, este
algoritmo
– Busca el elemento mayor de la lista ei
– Lo reubica al final, intercambiando ei con en
• Se aplica el mismo algoritmo pero
– Se reduce n en una unidad (n-1)
• Así, hasta que la lista solo contenga 2
elementos

31/10/2021
Selection Sort
5 1 3 4 6 2
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
5 1 3 4 6 2
Comparison
Data Movement
Sorted

Largest

31/10/2021
Selection Sort
5 1 3 4 2 6
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
5 1 3 4 2 6
Comparison
Data Movement
Sorted

Largest

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

Largest

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

Largest

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
2 1 3 4 5 6
Comparison
Data Movement
Sorted

Largest

31/10/2021
Selection Sort
1 2 3 4 5 6
Comparison
Data Movement
Sorted

31/10/2021
Selection Sort
1 2 3 4 5 6
Comparison
Data Movement
Sorted
DONE!

31/10/2021
Algoritmo selección
public static void selectionSort(int[] arr){
for (int i = 0; i < arr.length - 1; i++)
{
int index = i;
for (int j = i + 1; j < arr.length; j++){
if (arr[j] < arr[index]){
index = j;//searching for lowest index
}
}
int smallerNumber = arr[index];
arr[index] = arr[i];
arr[i] = smallerNumber;
}
}
public static void main(String a[]){
int[] arr1 = {9,14,3,2,43,11,58,22};
System.out.println("Before Selection Sort");
for(int i:arr1){
System.out.print(i+" ");
}
selectionSort(arr1);//sorting array using sele
ction sort
System.out.println("After Selection Sort");
for(int i:arr1){
}
}
Ejemplo de uso

31/10/2021
Contenido

31/10/2021
Algoritmo inserción
• Este método es usado por los jugadores de cartas.
Los elementos están divididos conceptualmente en
una secuencia destino y una secuencia fuente .
• En cada paso, comenzando con i=2 e incrementando i
en uno, el elemento i-ésimo de la secuencia fuente se
toma y se transfiere a la secuencia destino
insertándolo en el lugar adecuado.
• En otras palabras, en el i-ésimo paso insertamos el i-
ésimo elemento a[i] en su lugar correcto entre a[1],
a[2],…., a[i-1], que fueron colocados en orden
previamente.

31/10/2021
Ordenamiento por inserción directa
Variables
– K arreglo de datos a ordenar
– V variable auxiliar
– i, j índices para el arreglo
– N número de elementos
InserciónDirecta
Inicio
Para i=2 hasta N incremento 1
v = K(i) //elemento a acomodar
j = i
Mientras (j > 1) y (K(j-1) > v)
K(j) = K(j-1) //mueve elementos
j = j-1
K(j) = v // inserta el elemento actual
Fin
3 8 2 1 4
1 2 3 4 5 6
2
K
3 8
2 3 8
1 2 3 8
1 2 3 4 8
1 2 2 3 4 8

31/10/2021
Algoritmo inserción
public static void insertionSort(int array[]) {
int n = array.length;
for (int j = 1; j < n; j++) {
int key = array[j];
int i = j-1;
while ( (i > -1) && ( array [i] > key ) ) {
array [i+1] = array [i];
i--;
}
array[i+1] = key;
}
}
public static void main(String a[]){
int[] arr1 = {9,14,3,2,43,11,58,22};
System.out.println("Before Insertion Sort");
for(int i:arr1){
}
insertionSort(arr1);//sorting array using inser
tion sort
System.out.println("After Insertion Sort");
for(int i:arr1){
}
}
Ejemplo de uso

31/10/2021
Contenido

31/10/2021
Quicksort: divide y conquista
• Es el método de ordenación rápida mas veloz
• Pero
– Requiere gran cantidad de memoria para realizarlo
• Consiste en:
– Elija un elemento “pivote” al azar
• Podría ser fijo el elemento de la mitad
– Divida la lista en dos sublistas en base al pivote
– Se deberá ordenar cada sublista, para que
• Los elementos de la sublista izq. Sean menores al pivote
• Los elementos de la sublista der. Sean mayores al pivote

31/10/2021
Algoritmo rápido (Quicksort)
• Descripción del algoritmo:
1) Dividir : Si la secuencia S tiene 2 o más elementos,
seleccionar un elemento x de S como pivote. Cualquier
elemento arbitrario, como el último, puede servir. Elimiar los
elementos de S dividiéndolos en 3 secuencias:
L, contiene los elementos de S menores que x
E, contiene los elementos de S iguales a x
G, contiene los elementos de S mayores que x
2) Recursión: De forma recursiva ordenar L y G
3) Vencer: Finalmente, colocar nuevamente los elementos en S
en orden, primero insertar los elementos de L, después E, y
los elementos de G.

31/10/2021
El algoritmo
• Escoger el pivote k
– Usualmente el de la mitad
• Ubicar referencias
– i en el primer elemento y j en el ultimo
• Mientras i <= j
– Buscar primer elemento A[i] mayor o igual que A[k]
– Buscar primer elemento A[j] menor o igual que A[k]
– Si i <= j,
• intercambiar A[i] con A[j]
• I avanza y j retrocede un puesto
Aplicar
QuickSort a
cada sublista

31/10/2021
Análisis de quicksort
• El mejor de los casos ocurrirá cuando
– La división, en cada recursión,
• Produce dos sublistas de igual longitud
– La profundidad de la recursividad es
• Log(n)
– Y en cada nivel se trataran n elementos
– En este caso, cae en el grupo de n*log(n)
• El peor de los casos es cuando
– La división en cada reexcursión es desbalanceada
– La profundidad de la recursividad es n-1
– Y en ese caso, cae en el grupo n2

31/10/2021
Idea de Quick Sort
1) Selección: tomar un elemento
2) Dividir: reordenar los
elementos tal que x va a su
posición final E
3) Recursión y Vencer: ordenar
recursivamente

31/10/2021
Quick Sort
5 1 3 8 7 4 6 2
Elements < pivot Elements > pivot
Data Movement
Sorted

31/10/2021
Quick Sort
5 1 3 8 7 4 6 2
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
5 1 3 4 7 8 6 2
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
5 1 3 4 2 8 6 7
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
5 1 3 4 2 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
2 1 3 4 5 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
2 1 3 4 5 8 6 7
Data Movement
Sorted

31/10/2021
Quick Sort
2 1 3 4 5 8 6 7
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
2 1 3 4 5 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
1 2 3 4 5 8 6 7
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 7 6 8
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 7 6 8
Data Movement
Sorted

31/10/2021
Quick Sort
1 2 3 4 5 7 6 8
Data Movement
Sorted

Pivot

First
Unknown

31/10/2021
Quick Sort
1 2 3 4 5 7 6 8
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 6 7 8
Data Movement
Sorted

Pivot

31/10/2021
Quick Sort
1 2 3 4 5 6 7 8
Data Movement
Sorted

31/10/2021
Quick Sort
1 2 3 4 5 6 7 8
Data Movement
Sorted
DONE!

31/10/2021
Algoritmo Quicksort
public static void quicksort(int A[], int izq, int der) {
int pivote=A[izq]; // tomamos primer elemento como pivote
int i=izq; // i realiza la búsqueda de izquierda a derecha
int j=der; // j realiza la búsqueda de derecha a izquierda
int aux;
while(i < j){ // mientras no se crucen las búsquedas
while(A[i] <= pivote && i < j) i++; // busca elemento mayor que pivote
while(A[j] > pivote) j--; // busca elemento menor que pivote
if (i < j) { // si no se han cruzado
aux= A[i]; // los intercambia
A[i]=A[j]; A[j]=aux;
}
}
A[izq]=A[j]; // se coloca el pivote en su lugar de forma que tendremos
A[j]=pivote; // los menores a su izquierda y los mayores a su derecha
if(izq < j-1) quicksort(A,izq,j-1); // ordenamos subarray izquierdo
if(j+1 < der) quicksort(A,j+1,der); // ordenamos subarray derecho
}

31/10/2021
De forma gráfica el proceso sería el
siguiente:

31/10/2021
Contenido

31/10/2021
Ordenamiento de objetos
• Los diversos algoritmos que se han estudiado en los
apartados anteriores siempre han ordenado arrays de
un tipo de dato simple: int, double, ...
• La clase Vector de Java está diseñada para
almacenar objetos de cualquier tipo. En el Ejemplo se
almacenan objetos de clases diferentes.
class Racional {
private int numerador, denominador;
public Racional() {
numerado = 0;
denominador = 1;
}
public Racional(int n, int d)throws Exception {
super();
numerado = n;
if (d == 0) throw new Exception(" Denominador == 0");
denominador = d; }
...
}
for (int i = 0; i < 10; i++)
v.addElement(new Racional(5*i%7, 3*i+1));

31/10/2021
• ¿Cómo comparar objetos? ¿Qué criterio seguir para
determinar que el objeto p1 es menor que el objeto p2 ?
• Una alternativa consiste en declarar un interface con los
métodos menorQue(),menorIgualQue() …, y que las
clases de los objetos que se ordenan implementen el
interface.
interface Comparador {
boolean igualQue(Object op2);
boolean menorQue(Object op2);
boolean menorIgualQue(Object op2);
boolean mayorQue(Object op2);
boolean mayorIgualQue(Object op2);
}

31/10/2021
class Racional implements Comparador {
private int numerador, denominador;
public boolean igualQue(Object op2) {
Racional n2 = (Racional) op2;
return ((double)numerador / (double)denominador) ==
((double)n2.numerador / (double)n2.denominador );
}
public boolean menorQue(Object op2) {
return ((double)numerador / (double)denominador) <
}
public boolean menorIgualQue(Object op2) {
return ((double)numerador / (double)denominador) <=
}
public boolean mayorQue(Object op2) {
Racional n2 = (Racional) op2; return ((double)numerador / (double)denominador) >
}
public boolean mayorIgualQue(Object op2) {
return ((double)numerador / (double)denominador) >=
(double)n2.numerador / (double)n2.denominador );
}
}

31/10/2021
• Una vez establecidas las condiciones para realizar la
ordenación, falta por elegir alguno de los algoritmos de
ordenación.
• Debido a su sencillez, se emplea el algoritmo de la burbuja
(BubleSort)
public static void ordVector (Vector v) {
boolean interruptor = true;
int pasada, j;
int n = v.size();
// bucle externo controla la cantidad de pasadas
for (pasada = 0; pasada < n-1 && interruptor; pasada++) {
interruptor = false;
for (j = 0; j < n-pasada-1; j++) {
Racional r;
r = (Racional)v.elementAt(j);
if (r.mayorQue(v.elementAt(j+1))) {
// elementos desordenados, se intercambian
interruptor = true;
intercambiar(v, j, j+1);
}
}
}
}

31/10/2021
private static void intercambiar (Vector v, int i, int j)
{
Object aux = v.elementAt(i);
v.setElementAt(v.elementAt(j), i);
v.setElementAt(aux, j);
}

31/10/2021
Contenido

31/10/2021
Introducción
• Se trata de hallar un elemento de dato a
través de una valor llave. Existen dos
grupos de métodos de búsqueda:
– Métodos simples:
• Búsqueda lineal sobre un array
• Búsqueda lineal sobre una lista enlazada
• Búsqueda lineal sobre un array ordenado
• Búsqueda lineal sobre una lista enlazada
ordenada

31/10/2021
Introducción
– Métodos avanzados:
• Búsqueda binaria sobre un array ordenado
• Búsqueda por interpolación sobre un array
ordenado
• Búsqueda por interpolación sobre un array
ordenado
• Búsqueda binaria sobre un árbol binario de
búsqueda
• Búsqueda usando estrategia hash

31/10/2021
Contenido

31/10/2021
Búsqueda Secuencial
Consiste en ir comparando el elemento que se
busca con cada elemento del arreglo hasta
que se encuentra.
I N F O M Á T I C A
M M M M M
0 1 2 3 4 5 6 7 8 9
Índice resultado = 4

31/10/2021
Algoritmo Búsqueda Secuencial
for (i=0; i < LARGO; i++)
if (a[i]==Elemento_buscado)
printf(“Elemento encontrado en: %dn”, i);

31/10/2021
Contenido

31/10/2021
Búsqueda Binaria
Los elementos del arreglo se encuentran ordenados y no están
repetidos. En cada iteración el dominio de búsqueda se divide
en 2.
3 5 8 20 32 45 60 73
32 32
0 1 2 3 4 5 6 7
Resultado = 4
32

31/10/2021
Algoritmo Búsqueda Binaria
tipo A[LARGO]
Max=LARGO-1;
min=0;
Encontrado=0;
while(min+1<max && !Encontrado){
Medio=(Max+min)/2
if (A[Medio]==Elemento){
printf(“Elemento Encontradon”);
Encontrado=1; /*Fuerza la salida del ciclo*/
}
if (A[Medio]<Elemento) Max=Medio;
if (A[Medio]>Elemento) min=Medio;
}

31/10/2021
Recursividad,
ordenamiento y
búsqueda de datos
Unidad 2
Final de la unidad

ED Unidad 2: Recursividad, ordenamiento y búsqueda de datos

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to ED Unidad 2: Recursividad, ordenamiento y búsqueda de datos

Similar to ED Unidad 2: Recursividad, ordenamiento y búsqueda de datos (20)

More from Franklin Parrales Bravo

More from Franklin Parrales Bravo (20)

ED Unidad 2: Recursividad, ordenamiento y búsqueda de datos