Metodos De Ordenamiento y 
Búsquedas En Arreglos.  
15/15/2019  
Ricardo Daniel Martinez Banda. 
Juan Camilo trujillo Diaz. 
Programa: Ing de sistema. 
Curso:Estructura de datos. 
Profesor: Luis Roberto Olascoaga. 
Montería-Córdoba(Colombia). 
   

 
 1 
 

Introducción. 
a continuación encontraremos conceptos básicos de programación de funciones recursividad en 
java. sabiendo que recursividad no es un tema viejo puesto que en el campo de las matemáticas 
nos presenta ejemplos relacionados. Así mismo nos encontraremos métodos de ordenamiento 
QuickSort método que fue ideado por un científico inglés llamado Charles Anthony, en efecto fue 
un proyecto que se utilizaba como traducción de computadora(del ruso al inglés ).Además el uso 
este método para ordenar las palabras en ruso, para poder traducirlas y sin embargo este método 
se vio utilizado en otros campos de la informática. 
definiremos la búsqueda en el campo de programación siendo una operación que tiene por 
objeto la localización de un elemento dentro de la ESTRUCTURA DE DATOS. Del mismo modo 
encontraremos dos técnicas que se utilizan para encontrar un elemento en un arreglo que son 
búsqueda SECUENCIAL Y búsqueda BINARIA. 
 
 2 
 

Contenido. 

1. Recursividad: 

● características,  
● ventajas  
● desventajas. 

2. Método de ordenamiento por QuickSort: 

● descripción (funcionamiento). 
● algoritmo o código de su implementación en Java. 

3. Búsqueda secuencial:  

● ventajas. 
● desventajas. 

4. Búsqueda binaria:  

● ventajas. 
● desventajas. 

5.bibliografía. 

 
 3 
 

Recursividad:  
La recursividad es una técnica potente de programación que puede utilizarse en lugar de la 
iteración para resolver determinados tipos de problemas, así mismo recursividad se puede 
definir como una técnica que permite que una función se llame así misma. Son Recursivos 
aquellos algoritmos que, estando encapsulados dentro de una función, son llamados desde ella 
misma una y otra vez, en contraposición a los algoritmos que hacen uso de bucles while, 
do-while, for. 

Características. 
Consta de una parte recursiva, otra iterativa o no recursiva y una condición de terminación. La 
parte recursiva y la condición de terminación siempre existen. En cambio la parte no recursiva 
puede coincidir con la condición de terminación. 
Algo muy importante a tener en cuenta cuando usemos la recursividad es que es necesario 
asegurarnos que llega un momento en que no hacemos más llamadas recursivas. Si no se cumple 
esta condición el programa no parará nunca. 
 
ITERATIVO: 
int factorial( int n )
{
int res=1;
for(int i=1; i<=n; i++ )
res = res*i;
return(res);
}
RECURSIVO: 
int factorial( int n )
{
if(n==0) return(1);
return(n*Factorial(n-1));
}
 

 
 
 4 
 

 
Característica de la recursividad, Siempre existe una forma de salir de la definición.  
En un algoritmo recursivo distinguimos como mínimo 2 partes:  
a). Caso trivial, base o de fin de recursión: Una condición de salida que es la condición que no 
produce otra autollamada. Es un caso donde el problema puede resolverse sin tener que hacer 
uso de una nueva llamada a sí mismo. Evita la continuación indefinida de las partes recursivas. 
b). Parte puramente recursiva: Una llamada a sí mismo (recursiva); normalmente con el valor de 
los parámetros que cambian en cada llamada. Relaciona el resultado del algoritmo con 
resultados de casos más simples. Se hacen nuevas llamadas a la función, pero están más 
próximas al caso base. 

ventajas. 
La principal ventaja es la simplicidad de comprensión y su gran potencia, favoreciendo la 
resolución de problemas de manera natural, sencilla y elegante; y facilidad para comprobar y 
convencerse de que la solución del problema es correcta. 
En general las soluciones recursivas son más ineficientes en tiempo y en espacio que las 
versiones iterativas, esto es debido a las llamadas continuas a métodos, a la creación de 
variables dinámicas en la pila, y a la duplicación de variables por lo que la complejidad de los 
algoritmos recursivos tiende a ser muy alta. 

​desventajas. 
El principal inconveniente es la ineficiencia tanto en tiempo como en memoria, dado que para 
permitir su uso es necesario transformar el programa recursivo en otro iterativo, que utiliza 
bucles y pilas para almacenar las variables. 
 
 
 
 5 
 

 
Método de ordenamiento por QuickSort: 
descripción (funcionamiento). 
El método de ordenación Quicksort fue desarrollado por Hoare en el año 1960. 
Es el algoritmo de ordenación más rápido. 
Se  basa  en  la  técnica  ​divide  y  vencerás​,  que  consiste  en  ir  subdividiendo  el array en arrays más 
pequeños,  y  ordenar  éstos.  Para  hacer esta división, se toma un valor del array como ​pivote​, y se 
mueven  todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. 
A  continuación  se  aplica  el  mismo  método  a  cada  una  de  las  dos  partes  en  las  que  queda 
dividido el array. 
Después de elegir el pivote se realizan dos búsquedas: 
Una de izquierda a derecha, buscando un elemento mayor que el pivote 
Otra de derecha a izquierda, buscando un elemento menor que el pivote. 
Cuando  se  han  encontrado  los  dos  elementos  anteriores,  se  intercambian,  y  se  sigue realizando 
la búsqueda hasta que las dos búsquedas se encuentran. 
La implementación del método de ordenación Quicksort es claramente recursiva. 
Suponiendo  que  tomamos  como  pivote  el  primer  elemento,  el  método  Java  Quicksort  que 
implementa  este  algoritmo  de  ordenación  para  ordenar  un  array  de  enteros  se  presenta  a 
continuación.  Los parámetros izq y der son el primer y último elemento del array a tratar en cada 
momento. 
El  método ordena un array A de enteros desde la posición izq hasta la posición der. En la primera 
llamada recibirá los valores izq = 0, der = ELEMENTOS-1. 

 
 
 
 6 
 

 
algoritmo o código de su implementación en Java. 

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

 
 
 7 
 

De forma gráfica el proceso sería el siguiente: 

 
La  elección  del  pivote  determinará  la  eficiencia  de  este  algoritmo  ya que determina la partición 
del  array.  Si  consideramos  que  el  array  está  desordenado,  podemos  elegir  el  primer  elemento  y 
el  algoritmo  funciona  de  forma  eficiente.  Pero  si  el  array  está  casi  ordenado,  elegir  el  primer 
elemento  como  pivote  sería  una  mala  solución  ya  que obtendremos un subarray muy pequeño y 
otro  muy  grande.  Por  la  misma  razón,  elegir  el  último  elemento  del  array  como  pivote  también 
es  una  mala  idea.  Pretendemos  conseguir  que  el  tamaño  de  los  subarrays  sea  lo  más  parecido 
posible. 
Una  alternativa  a  elegir  el  primer  elemento  es  elegir  como  pivote  un  elemento  al  azar de entre 
todos los del array. 
Otra estrategia es calcular la mediana de los valores de la izquierda, centro y derecha del vector. 
Por  ejemplo  para el vector: 9 8 1 6 10 2 3, se calcula la mediana de los elementos que ocupan el 
primer  lugar,  el  último  y  el  centro  o  sea  9  3 6. La mediana es 6 que determinaría las particiones 
{1 3 2} {6} {8 10 9}. 
En  el  peor  caso,  cuando  el  pivote  es  el  elemento  menor  del  array  el  tiempo  de  ejecución  del 
método Quicksort es O(n​2​). 
En general el tiempo medio de ejecución del Quicksort es O(n log n). 
 8 
 

Búsqueda secuencial: 
La búsqueda secuencial, también se le conoce como búsqueda lineal. 

Supongamos una colección de ​registros organizados como una lista lineal. El algoritmo básico de 
búsqueda  secuencial  consiste  en  empezar  al  inicio  de  la  lista e ir a través de cada ​registro hasta 
encontrar la clave indicada (k) o hasta el final de la lista. 

Este  método  consiste  en  recorrer  el  arreglo  o  vector  elemento  a  elemento  e  ir  comparando  con 
el valor buscado (clave). Se empieza con la primera casilla del vector y se observa una casilla tras 
otra  hasta  que  se  encuentre  el  elemento  buscado  o  se  han  visto  todas  las  casillas.  El  resultado 
de  la  búsqueda  es  un  solo  valor,  y  será  la  posición  del  elemento  buscado  o  cero.  Dado  que  el 
vector  o  arreglo  no  está  en  ningún  orden  en  particular,  existe  la  misma  ​probabilidad  de  que  el 
valor  se  encuentra  ya  se  en  el  primer elemento, como en el último. Por lo tanto, en promedio, el 
programa tendrá que comparar el valor buscado con la mitad de los elementos del vector. 

El  método  de  búsqueda  lineal  funciona  bien  con  arreglos  pequeños  o  para  arreglos  no 
ordenados. 

El método de búsqueda secuencial consiste en ir comparando el elemento o criterio de búsqueda 
con  cada  uno  de  los  elementos  en  el arreglo, esto se hace recorriendo el arreglo y deteniéndose 
en  cada  elemento  y  hacer  la  comparación,  en  caso  de  ser  verdadera  la  comparación,  guardar  la 
posición el elemento o dato. 

 
 9 
 

He aquí el código: 

public int busquedaSecuencial(int []arreglo,int dato){

int posicion = -1;

for(int i = 0; i < arreglo.length; i++){//recorremos todo el arreglo

if(arreglo[i] == dato){//comparamos el elemento en el arreglo con el buscado

posición = i;//Si es verdadero guardamos la posición

break;//Para el ciclo

return posicion;

Este  método  nos  halla  la  posición del elemento o dato buscado pero en su primero coincidencia, 

si  queremos  que  nos  halle  la posición de la última coincidencia, lo único que tenemos que hacer 
es eliminar la línea donde aparece 'break'. 

Si  el  resultado  del  método  anterior  es  -1,  significa  que  el  elemento  no  se  encuentra  en  el 
arreglo. 

Ahora  cabe  la  pregunta,  ¿y  si  el  elemento  que  deseo  buscar  aparece varias veces en el arreglo y 
yo deseo conocer cada una de estas posiciones, como hago? 

Lo  que  hacemos  es  deshacernos  de  la  línea  'break'  para  que  el  vector  sea  recorrido  en  su 
totalidad,  y  de  alguna  forma  ir  almacenando  cada  una  de  las  posiciones  resultantes  de  las 
comparaciones verdaderas. 

 
 10 
 

He aquí el código: 

public String busquedaSecuencial2(int []arreglo,int valor){

String posición = "";

for(int i = 0; i < arreglo.length; i++){

if(arreglo[i] == valor){

posición += i+",";

return posicion;

Aunque  pude  haber  usado  un  'ArrayList'  o  'Vector'  preferí  usar  un  'String'  porque  asumo  que  el 
lector de éste articulo está más familiarizado con esta última que con los dos primeros términos. 

Como siempre esperando que lo escrito les sea de utilidad. 

ventajas. 
❏ Es  un  método  sumamente  simple  que  resulta  útil cuando se tiene un conjunto de 
datos pequeños (Hasta aproximadamente 500 elementos) 
❏ Es  fácil  adaptar  la  búsqueda  secuencial  para  que  utilice  una  lista  enlazada 
ordenada, lo que hace la búsqueda más eficaz. 
❏ Si  los  datos  buscados no están en orden es el único método que puede emplearse 
para hacer dichas búsquedas. 
 11 
 

 
desventajas. 
❏ Este método tiende hacer muy lento. 
❏ Si  los  valores  de  la  clave  no  son  únicos,  para  encontrar  todos  los  elementos  con 
una  clave  particular,  se  requiere  buscar  en todo el arreglo, lo que hace el ​proceso 
muy largo. 

Búsqueda binaria:  
La  búsqueda  binaria  es  el  método,  donde  si  el  arreglo  o  vector  está  bien  ordenado,  se 
reduce  sucesivamente  la  operación  eliminando  repetidas  veces  la  mitad  de  la  lista 
restante. 

El  proceso  comienza  comparando  el  elemento  central  del  arreglo  con  el  elemento 
buscado.  Si  ambos  coinciden  finaliza  la  búsqueda.  Si  no  ocurre  así,  el  elemento buscado 
será  mayor  o  menor  en  sentido  estricto  que  el  elemento  central  del  arreglo.  Si  el 
elemento  buscado  es  mayor  se procede a hacer búsqueda binaria en el subarray superior, 
si  el  elemento  buscado  es  menor  que  el  contenido  de  la  casilla  central, se debe cambiar 
el segmento a considerar al segmento que está a la izquierda de tal sitio central. 

  Este  método  se  puede  aplicar  tanto  a  datos  en  listas  lineales  como  en  ​árboles  binarios 
de búsqueda. Los pre – requisitos para la búsqueda binaria son: 

❏ La  lista  debe  estar  ordenada,  en  un  orden  específico  de  acuerdo  al  valor  de  la 
clave. 
❏ Debe conocerse el número de elementos. 
 12 
 

❏ Si  el  conjunto  de  elementos  es  grande,  el  tiempo  de  búsqueda  se  puede  reducir 
utilizando el siguiente algoritmo de tipo divide y vencerás: 
❏ Se divide el elemento en dos partes. 
❏ Se determina la parte que debe contener la clave buscada. 
❏ Se repite el proceso en esa parte. 

Una forma razonable de dividir el conjunto de elementos es mantener los elementos ordenados 
y después utilizar los índices del arreglo ordenado para determinar la parte del arreglo sobre la 
que se va a trabajar. 

Para implementar este algoritmo se compara el elemento a buscar con un elemento cualquiera 
del array (normalmente el elemento central): si el valor de éste es mayor que el del elemento 
buscado se repite el procedimiento en la parte del array que va desde el inicio de éste hasta el 
elemento tomado, en caso contrario se toma la parte del array que va desde el elemento tomado 
hasta el final. De esta manera obtenemos intervalos cada vez más pequeños, hasta que se 
obtenga un intervalo indivisible. Si el elemento no se encuentra dentro de este último entonces 
se deduce que el elemento buscado no se encuentra en todo el array (wikipedia). 

He aquí el código que les ofrezco. 

 

class BusquedaBinaria{

/**

* Busca un valor numerico dentro de un arreglo numerico...

* previamente ordenado usando el metodo de busqueda binaria

* @param arreglo con los elementos; dato a buscar

* @return posicion del elemento buscado, en caso de no existir retorna -1

*/

public static int busquedaBinaria(int vector[], int dato){

 13 
 

int n = vector.length;

​int centro,inf=0,sup=n-1;

while(inf<=sup){

centro=(sup+inf)/2;

if(vector[centro]==dato) return centro;

else if(dato < vector [centro] ){

sup=centro-1;

else {

inf=centro+1;

return -1;

public static void main(String []args){

int[]vector ={1,4,7,8,9,14,23,47,56,60,61,63,65,66,68,69,70,73,76,77,79,80,82};

int valorBuscado = 70;

System.out.println(busquedaBinaria(vector,valorBuscado));

}
 

ventajas.
❏ Se  puede  aplicar  tanto  a  datos  en  listas  lineales  como  en  árboles  binarios  de 
búsqueda. 
❏ Es el método más eficiente para encontrar elementos en un arreglo ordenado. 

 
 14 
 

desventajas. 

❏ Este método funciona solamente con arreglos ordenados, por lo cual si nos 
encontramos con arreglos que no están en orden, este método, no nos ayudaría 
en nada. 

bibliografía. 
● http://puntocomnoesunlenguaje.blogspot.com/2012/04/recursividad-en-java.html 
● http://jitorres.blogspot.com/2011/08/recursividad.html 
● http://dptocomp.ing.uc.edu.ve/compAvanzada/lecturas/Recursividad.pdf 
● https://es.slideshare.net/rehoscript/unidad-4-est-dat-recursividad 
● http://usandojava.blogspot.com/2012/11/busqueda-binaria-en-un-arreglo-usando.html 
● http://usandojava.blogspot.com/2012/10/busqueda-secuencial-en-un-arreglo.html 
● https://uneginginf05.es.tl/M-e2-todo-de-Busqueda-Secuencial-y-Binaria.htm