PRÁCTICO ALGORITMOS I

(Ordenamiento y Búsqueda)

Alumno: Tamir Jordán Lima

Registro: 2015112154

Docente: Mgs. Rolando Martínez Canedo

Materia: IS-120

Santa Cruz, 03/06/2016

 METODOS DE ORDENAMIENTO

BURBUJA
Método.- Este método consiste en acomodar el vector moviendo el mayor hasta la última casilla
comenzando desde la casilla cero del vector hasta haber acomodado el número más grande a la última
posición, una vez acomodado el más grande, prosigue a encontrar y acomodar el siguiente más grande
comparando de nuevo los números desde el inicio del vector, y así sigue hasta ordenar todo los
elementos el arreglo. Este algoritmo es muy deficiente ya que al ir comparando las casillas para buscar el
siguiente más grande, éste vuelve a comparar las ya ordenadas. A pesar de ser el algoritmo de
ordenamiento más deficiente que hay, éste es el más usado en todos los lenguajes de programación.

Esquema Gráfico.-

Algoritmo.-
void ordenarburbuja(int v[],int n)
{
int aux, i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (v[j] > v[i])
{
aux = v[j];
v[j] = v[i];
v[i] = aux;
}
}
}
}
BARAJA
Método.- Consiste en insertar un elemento en el vector en una parte ya ordenada de este vector y
comenzar de nuevo con los elementos restantes. Por ser utilizado generalmente por los jugadores de
cartas se le conoce también por el método de la baraja.

El método se basa en comparaciones y desplazamientos sucesivos. El algoritmo de clasificaciones de un

vector X para N elementos se realiza con un recorrido de todo el vector y la inserción del elemento
correspondiente en el lugar adecuado. El recorrido se realiza desde el segundo elemento al n-ésimo.

Esquema Gráfico.-

Algoritmo.-
void ordenarbaraja(int vec[], int n)
{
int i, j, aux;
for (i = 1; i<n; i++) {
j = i;
while (j >= 0 && vec[j]<vec[j - 1]) {
aux = vec[j];
vec[j] = vec[j - 1];
vec[j - 1] = aux;
j--;
}
}
}
QUICK SORT
Método.- El ordenamiento por partición (Quick Sort) se puede definir en una forma más conveniente
como un procedimiento recursivo.

Tiene aparentemente la propiedad de trabajar mejor para elementos de entrada desordenados

completamente, que para elementos semiordenados. Esta situación es precisamente la opuesta al
ordenamiento de burbuja.

Este tipo de algoritmos se basa en la técnica "divide y vencerás", o sea es más rápido y fácil ordenar dos
arreglos o listas de datos pequeños, que un arreglo o lista grande.

Normalmente al inicio de la ordenación se escoge un elemento aproximadamente en la mitad del

arreglo, así al empezar a ordenar, se debe llegar a que el arreglo este ordenado respecto al punto de
división o la mitad del arreglo.

Se podrá garantizar que los elementos a la izquierda de la mitad son los menores y los elementos a la
derecha son los mayores.

Los siguientes pasos son llamados recursivos con el propósito de efectuar la ordenación por partición al
arreglo izquierdo y al arreglo derecho, que se obtienen de la primera fase. El tamaño de esos arreglos en
promedio se reduce a la mitad.

Así se continúa hasta que el tamaño de los arreglos a ordenar es 1, es decir, todos los elementos ya
están ordenados.

En promedio para todos los elementos de entrada de tamaño n, el método hace O(n log n)
comparaciones, el cual es relativamente eficiente.

Esquema Gráfico.-
Algoritmo.-
void ordenarquick(int vect[], int izq, int der)
{
int i = 0, j = 0;
int x = 0, aux = 0;
i = izq;
j = der;
x = vect[(izq + der) / 2];
do{
while ((vect[i] < x) && (j <= der)){
i++;
}
while ((x < vect[j]) && (j > izq)){
j--;
}
if (i <= j){
aux = vect[i];
vect[i] = vect[j];
vect[j] = aux;
i++; j--;
}
} while (i <= j);
if (izq < j)
ordenarquick(vect, izq, j);
if (i < der)
ordenarquick(vect, i, der);
}
 METODOS DE BUSQUEDA

SECUENCIAL
Método.- Se utiliza cuando el contenido del Vector no se encuentra o no puede ser ordenado. Consiste
en buscar el elemento comparándolo secuencialmente (de ahí su nombre) con cada elemento del
arreglo o conjunto de datos hasta que se encuentre, o hasta que se llegue al final del arreglo. La
existencia se puede asegurar desde el momento que el elemento es localizado, pero no podemos
asegurar la no existencia hasta no haber analizado todos los elementos del arreglo.

Esquema Gráfico.-

Algoritmo.-
void busquedasecuencial(int vec[],int n,int x)
{
int i, pos, band = 0;
for (i = 0; i<n; i++)
{
if (vec[i] == x)
{
pos = i;
i = n;
band = 1;
}
}
if (band == 0)
{
cout << "ELEMENTO NO ENCONTRADO";
}
else
{
cout << "Posicion del elemento: " << pos;
}
}
BINARIA
Método.- Se utiliza cuando el vector en el que queremos determinar la existencia o no de un elemento
está ordenado, o puede estarlo, este algoritmo reduce el tiempo de búsqueda considerablemente, ya
que disminuye exponencialmente con el número de iteraciones.

Para implementar este algoritmo se compara el elemento a buscar con un elemento cualquiera del
arreglo o conjunto de datos (habitualmente el elemento en la posición central del arreglo), si el valor de
éste es mayor que el del elemento buscado se repite el procedimiento en la parte del arreglo que va
desde el inicio de éste hasta el elemento tomado, en caso contrario se toma la parte del arreglo 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, con el elemento buscado como elemento central. Si el
elemento no se encuentra dentro de este último entonces se deduce que el elemento buscado no se
encuentra en el arreglo.

Esquema Grafico.-
Algoritmo.-
void busquedabinaria(int vec[], int n, int clave)
{
int Iarriba = n - 1;
int Iabajo = 0;
int Icentro;
bool k = false;
while (Iabajo <= Iarriba)
{
Icentro = (Iarriba + Iabajo) / 2;
if (vec[Icentro] == clave)
{
cout << endl << "Posicion: " << Icentro;
k = true;
}
else
{
if (clave < vec[Icentro])
{
Iarriba = Icentro - 1;
}
else
{
Iabajo = Icentro + 1;
}
}
}
if (k == false)
{
cout << "ELEMENTO NO ENCONTRADO";
}
}
 PROGRAMAS EN LENGUAJE C (EJEMPLOS)

Métodos de Ordenamiento
#include <iostream>
#include <conio.h>
using namespace std;

void cargarvector(int vec[], int &n)

{
int i;
cout << endl << "Ingrese tamano: ";
cin >> n;
for (i = 0; i < n; i++)
{
cout << endl << "Ingrese valor en vec[" << i + 1 << "]: ";
cin >> vec[i];
}
}

void mostrarvector(int vec[], int n)

{
int i;
for (i = 0; i < n; i++)
{
cout << endl << "vec[" << i + 1 << "]: " << vec[i];
}
}

void ordenarburbuja(int v[], int n)

{
int aux, i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (v[j] > v[i])
{
aux = v[j];
v[j] = v[i];
v[i] = aux;
}
}
}
}

void ordenarbaraja(int vec[], int n)

{
int i, j, aux;
for (i = 1; i<n; i++) {
j = i;
while (j >= 0 && vec[j]<vec[j - 1]) {
aux = vec[j];
vec[j] = vec[j - 1];
 vec[j - 1] = aux;
j--;
}
}
}

void ordenarquick(int vect[], int izq, int der)

{
int i = 0, j = 0;
int x = 0, aux = 0;
i = izq;
j = der;
x = vect[(izq + der) / 2];
do{
while ((vect[i] < x) && (j <= der)){
i++;
}
while ((x < vect[j]) && (j > izq)){
j--;
}
if (i <= j){
aux = vect[i];
vect[i] = vect[j];
vect[j] = aux;
i++; j--;
}
} while (i <= j);
if (izq < j)
ordenarquick(vect, izq, j);
if (i < der)
ordenarquick(vect, i, der);
}

void main()
{
int menu, vec[20], n;
do
{
cout << endl << "------------MENU-----------";
cout << endl << "1.- Ordenar por burbuja";
cout << endl << "2.- Ordenar por baraja";
cout << endl << "3.- Ordenar por quick sort";
cout << endl << "0.- Salir";
do
{
cout << endl << "Ingrese opcion: ";
cin >> menu;
} while (menu > 3 || menu < 0);
if (menu == 1)
{
cargarvector(vec,n);
ordenarburbuja(vec,n);
mostrarvector(vec,n);
}
if (menu == 2)
{
cargarvector(vec, n);
ordenarbaraja(vec, n);
 mostrarvector(vec, n);
}
if (menu == 3)
{
cargarvector(vec, n);
ordenarquick(vec, 0, n);
mostrarvector(vec, n);
}
} while (menu != 0);
_getch();
}
Métodos de Búsqueda
#include <iostream>
#include <conio.h>
using namespace std;

void cargarvector(int vec[], int &n)

{
int i;
cout << endl << "Ingrese tamano: ";
cin >> n;
for (i = 0; i < n; i++)
{
cout << endl << "Ingrese valor en vec[" << i + 1 << "]: ";
cin >> vec[i];
}
}

int pedirnro()
{
int x;
cout << endl << "Ingrese numero a buscar: ";
cin >> x;
return(x);
}

void busquedasecuencial(int vec[], int n, int x)

{
int i, pos, band = 0;
for (i = 0; i<n; i++)
{
if (vec[i] == x)
{
pos = i;
i = n;
band = 1;
}
}
if (band == 0)
{
cout << "ELEMENTO NO ENCONTRADO";
}
else
{
cout << endl << "Posicion: " << pos;
}
}

void busquedabinaria(int vec[], int n, int clave)

{
int Iarriba = n - 1;
int Iabajo = 0;
int Icentro;
bool k = false;
while (Iabajo <= Iarriba)
{
Icentro = (Iarriba + Iabajo) / 2;
 if (vec[Icentro] == clave)
{
cout << endl << "Posicion: " << Icentro;
k = true;
}
else
{
if (clave < vec[Icentro])
{
Iarriba = Icentro - 1;
}
else
{
Iabajo = Icentro + 1;
}
}
}
if (k == false)
{
cout << "ELEMENTO NO ENCONTRADO";
}
}

void main()
{
int menu, vec[20], n, x;
do
{
cout << endl << "------------MENU-----------";
cout << endl << "1.- Busqueda secuencial";
cout << endl << "2.- Busqueda Binaria";
cout << endl << "0.- Salir";
do
{
cout << endl << "Ingrese opcion: ";
cin >> menu;
} while (menu > 2 || menu < 0);
if (menu == 1)
{
cargarvector(vec,n);
x = pedirnro();
busquedasecuencial(vec, n, x);
}
if (menu == 2)
{
cargarvector(vec, n);
x = pedirnro();
busquedabinaria(vec, n, x);
}
} while (menu != 0);
_getch();
}