REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA DEFENSA

UNIVERSIDAD NACIONAL EXPERIMENTAL POLITECNICA DE
LA FUERZA ARMADA
UNEFA – NUCLEO LARA

METODOS DE ORDENAMIENTO Y
METODOS DE BUSQUEDA

INTEGRANTE:
ROYMAN CAMACARO C. 22333453
SECCION: 05S-2613-D1
PROF: EDWAR PEREIRA
METODOS DE ORDENAMIENTO

Debido a que las estructuras de datos son utilizadas para

almacenar información, para poder recuperar esa información de
manera eficiente es deseable que aquella esté ordenada. Existen varios
métodos para ordenar las diferentes estructuras de datos básicas.

Los métodos sencillos por lo general requieren de

aproximadamente n x n pasos para ordenar n elementos.

Los métodos simples son: insertion sort (o por inserción directa)

selection sort, bubble sort, y shellsort, en dónde el último es una
extensón al insertion sort, siendo más rápido. Los métodos más
complejos son el quick-sort, el heap sort, radix y address-calculation
sort. El ordenar un grupo de datos significa mover los datos o sus
referencias para que queden en una secuencia tal que represente un
orden, el cual puede ser numérico, alfabético o incluso alfanumérico,
ascendente o descendente.
 ORDENAMIENTO DE BURBUJA  EJEMPLO:

#include<stdio.h>
La Ordenación de burbuja (Bubble Sort en inglés) es un #include<conio.h>
sencillo algoritmo de ordenamiento. Funciona revisando cada int a[3]={3,2,1};
elemento de la lista que va a ser ordenada con el siguiente, int i,j,aux,n=3;
intercambiándolos de posición si están en el orden equivocado. void main(){
Es necesario revisar varias veces toda la lista hasta que no se clrscr();
necesiten más intercambios, lo cual significa que la lista está for(i=0;i<=n;i++){
ordenada. for(j=0;j<n-1;j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
for(i=0;i<3;i++)
{
printf("%d",a);
}
getch();
}
 ORDENAMIENTO SHELL

El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se

denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e
intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con
un rendimiento de O(n log2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por
algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo
funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.

#include<stdio.h> while(inter>0){ inter=inter/2;

#include<conio.h> for(i=inter;i<n;i++) }
int a[5]; { for(i=0;i<5;i++)
j=i-inter;
int n=5; while(j>=0) {
{
void main() k=j+inter; printf("%d n",a);
{ if(a[j]<=a[k]){ getch();
int inter=(n/2),i=0,j=0,k=0,aux; j--; }
clrscr(); } }  
for (i=0; i<5; i++) else{
{ aux=a[j];
a[j]=a[k];
printf("INSERTA UN VALOR DEL a[k]=aux;
INDICE %d", i); j=j-inter;
scanf("%d",& a); }
} }
}
 Ejemplo:
ORDENAMIENTO POR INSERCION
#include<stdio.h>
El ordenamiento por inserción (insertion sort en inglés) es #include<conio.h>
una manera muy natural de ordenar para un ser humano, y int a[4]={4,1,7,2};
puede usarse fácilmente para ordenar un mazo de cartas int n=4;
numeradas en forma arbitraria. Requiere O(n²) operaciones para int i,j,aux;
ordenar una lista de n elementos. void main(){
clrscr();
for(i=1;i<n;i++)
{
j=i;
aux=a;
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
{
printf("%d",a);
}
getch();
}
 ORDENAMIENTO POR SELECCION

El ordenamiento por selección (Selection Sort en De esta manera se puede escribir el

inglés) es un algoritmo de ordenamiento que requiere siguiente pseudocódigo para ordenar una
O  operaciones para ordenar una lista de n lista de n elementos indexados desde el
elementos. 1:

Su funcionamiento es el siguiente:
CODE
•Buscar el mínimo elemento de la lista. para i=1 hasta n-1
•Intercambiarlo con el primero. minimo = i; para j=i+1 hasta n
•Buscar el mínimo en el resto de la lista. si lista[j] < lista[minimo] entonces
•Intercambiarlo con el segundo. minimo = j /* (!) */
fin si
Y en general: fin para
intercambiar(lista[i], lista[minimo])
•Buscar el mínimo elemento entre una posición i y el fin para 
final de la lista
•Intercambiar el mínimo con el elemento de la
posición i
EJERCICIO METODO DE ORDENAMIENTO

#include <stdio.h>
#define SIZE 7
void main(void) {
int vector[SIZE]; /* se aplica el algoritmo de la burbuja */
int j, i, temp; for(i=0; i<(SIZE-1); i++) {
printf("Introduce los %d valores para ordenar:\n", SIZE); or (j=i+1; j<SIZE; j++) {
for(i=0; i<SIZE; i++) { if(vector[j]<vector[i]) {
printf("%d: ", i+1); temp=vector[j];
scanf("%d", &vector[i]); vector[j]=vector[i];
printf("\n"); vector[i]=temp;
} }
}
}
printf("El vector ordenado es:\n");
for(i=0; i<SIZE ; i++) {
printf("%d ", vector[i]); }
printf("\n");
}
 METODOS DE BUSQUEDA

La búsqueda de un elemento dentro de un array es una

de las operaciones más importantes en el procesamiento de
la información, y permite la recuperación de datos
previamente almacenados.

El tipo de búsqueda se puede clasificar como interna o

externa, según el lugar en el que esté almacenada la
información (en memoria o en dispositivos externos). Todos
los algoritmos de búsqueda tienen dos finalidades:

•Determinar si el elemento buscado se encuentra en el

conjunto en el que se busca.
•Si el elemento está en el conjunto, hallar la posición en la
que se encuentra.

 
BÚSQUEDA LINEAL (SECUENCIAL)

Consiste en recorrer y examinar cada uno de los elementos del En este último caso, cuando sólo
array hasta encontrar el o los elementos buscados, o hasta que se han interesa la primera posición, se puede utilizar
mirado todos los elementos del array. un centinela, esto es, dar a la posición
Este es el método de búsqueda más lento, pero si nuestra información siguiente al último elemento de array el valor
se encuentra completamente desordenada es el único que nos podrá
del elemento, para estar seguro de que se
ayudar a encontrar el dato que buscamos. El siguiente algoritmo ilustra
un esquema de implementación del algoritmo de búsqueda secuencial: encuentra el elemento, y no tener que
comprobar a cada paso si seguimos
for(i=j=0;i<N;i++) buscando dentro de los límites del array:
   if(array[i]==elemento)
   { array[N]=elemento;
     solucion[j]=i;
for(i=0;;i++)
     j++;
   }   if(array[i]==elemento)
    break;
Este algoritmo se puede optimizar cuando el array está
ordenado, en cuyo caso la condición de salida cambiaría a:
Si al acabar el bucle, i vale N esto
for(i=j=0;array[i]<=elemento;i++) indica que no se encontró el elemento. El
número medio de comparaciones que hay
o cuando sólo interesa conocer la primera ocurrencia del elemento en que hacer antes de encontrar el elemento
el array: buscado es de (N+1)/2.
for(i=0;i<N;i++)
  if(array[i]==elemento)
    break;
COMPLEJIDAD DE LA BÚSQUEDA LINEAL.

(A) MEJOR CASO: El algoritmo de búsqueda lineal termina tan pronto como encuentra el elemento buscado en
el array. Si tenemos suerte, puede ser que la primera posición examinada contenga el elemento que buscamos,
en cuyo caso el algoritmo informará que tuvo éxito después de una sola comparación. Por tanto, la complejidad
en este caso será O(1).

(B) PEOR CASO: Sucede cuando encontramos X en la última posición del array. Como se requieren n
ejecuciones del bucle mientras, la cantidad de tiempo es proporcional a la longitud del array n, más un cierto
tiempo para realizar las instrucciones del bucle mientras y para la llamada al método. Por lo tanto, la cantidad de
tiempo es de la forma an + b (instrucciones del mientras * tamaño del arreglo + llamada al método) para ciertas
constantes a y b, que representan el coste del bucle mientras y el costo de llamar el método respectivamente.
Representando esto en notación O, O(an+b) = O(n).

(C) CASO MEDIO: Supongamos que cada elemento almacenado en el array es igualmente probable de ser
buscado. La media puede calcularse tomando el tiempo total de encontrar todos los elementos y dividiéndolo por
n:

Total = a (1 + 2 + ...+n) + bn = a (n(n+1) / 2) + bn, a representa el costo constante asociado a la ejecución del
ciclo y b el costo constante asociado a la evaluación de la condición. 1, 2 , ..n, representan el costo de encontrar
el elemento en la primera, segunda, ..., enésima posición dentro del arreglo.
Media = (Total / n) = a((n+1) / 2) + b que es O(n).
 Este es el algoritmo de más simple implementación pero no el más efectivo. En el peor de los
casos se recorre el array completo y el valor no se encuentra o se recorre el array completo si el valor
buscado está en la última posición del array. La ventaja es su implementación sencilla y rápida, la
desventaja, su ineficiencia.

BÚSQUEDA BINARIA (DICOTÓMICA)

Si los elementos sobre los que se realiza la búsqueda están ordenados, entonces podemos utilizar
un algoritmo de búsqueda mucho más rápido que el secuencial, la búsqueda binaria. El algoritmo
consiste en reducir paulatinamente el ámbito de búsqueda a la mitad de los elementos, basándose en
comparar el elemento a buscar con el elemento que se encuentra en la mitad del intervalo y en base a
esta comparación:

•Si el elemento buscado es menor que el elemento medio, entonces sabemos que el elemento está en
la mitad inferior de la tabla.
•Si es mayor es porque el elemento está en la mitad superior.
•Si es igual se finaliza con éxito la búsqueda ya que se ha encontrado el elemento.

Se puede aplicar tanto a datos en listas lineales (Vectores, Matrices, etc.) como en árboles binarios de
búsqueda. Los prerrequisitos principales para la búsqueda binaria son:

•La lista debe estar ordenada en un orden especifico de acuerdo al valor de la llave.
•Debe conocerse el número de registros.
 La búsqueda binaria consiste en dividir el array por
su elemento medio en dos subarrays más pequeños, y
comparar el elemento con el del centro. Si coinciden, la
búsqueda se termina. Si el elemento es menor, debe
estar (si está) en el primer subarray, y si es mayor está en
el segundo. Por ejemplo, para buscar el elemento 3 en el
array {1,2,3,4,5,6,7,8,9} se realizarían los siguientes
pasos:

Se toma el elemento central y se divide el array en dos:

{1,2,3,4}-5-{6,7,8,9}

Como el elemento buscado (3) es menor que el central

(5), debe estar en el primer subarray: {1,2,3,4}

Se vuelve a dividir el array en dos:

{1}-2-{3,4}

Como el elemento buscado es mayor que el central, debe

estar en el segundo subarray: {3,4}
Se vuelve a dividir en dos:
{}-3-{4}
Como el elemento buscado coincide con el central, lo hemos
encontrado.

Si al final de la búsqueda todavía no lo hemos encontrado, y

el subarray a dividir está vacio {}, el elemento no se
encuentra en el array. La implementación sería:
medio=(desde+hasta)/2; // Divide el array
int desde,hasta,medio,elemento,posicion; // desde y hasta en dos.
indican los límites del array que se está mirando.    if(array[medio]==elemento) // Si coincide
con el central:
int array[N];    {
// Dar valor a elemento.      posicion=medio; // ese es la solución
for(desde=0,hasta=N-1;desde<=hasta;)      break; // y sale del bucle.
{    }
   if(desde==hasta) // si el array sólo tiene un elemento:    else
   {      if(array[medio]>elemento) // si es
     if(array[desde]==elemento) // si es la solución: menor:
       posicion=desde; // darle el valor.        hasta=medio-1; // elige el array de la
     else // si no es el valor: izquierda.
       posicion=-1; // no está en el array.      else // y si es mayor:
     break; // Salir del bucle.       desde=medio+1; // elige el array de la
   } derecha.
   
}
VERSIÓN RECURSIVA DE LA BÚSQUEDA BINARIA.

Su única novedad es que después de comparar el elemento

de búsqueda con el elemento de la mitad de la tabla, se invoca
recursivamente a realizar la búsqueda en uno de los dos posibles
intervalos, el inferior o el superior, finalizando en el momento en
el que se encuentre el elemento o ya se tenga un único elemento
y no coincida con el buscado.

int binariaRecursiva(int A[], int X, int inicio,

int fin)
{
   int medio;
   if (inicio > fin) return -1;
   else
   {
      medio = inicio+(inicio+fin)/2;
      if (A[medio] < X) return
binariaRecursiva(A,X,medio+1,fin);
      else if (A[medio] > X) return
binariaRecursiva(A,X,inicio,medio -1);
      else return medio;
GRACIAS POR SU ATENCION