VICERRECTORADO DOCENTE Código: GUIA-PRL-001

CONSEJO ACADÉMICO Aprobación: 2016/04/06

Práctica de Laboratorio 01

CARRERA: CIENCIAS DE LA ASIGNATURA: ESTRUCTURA DE DATOS G2

COMPUTACIÓN
NRO. PRÁCTICA: 1 TÍTULO PRÁCTICA: MÉTODOS DE ORDENACIÓN

INTEGRANTE(S): Alexis Vallejo Guaipatín

OBJETIVO GENERAL
Comprender e implementar los Métodos de Ordenación.

OBJETIVOS ESPECÍFICOS

 Determinar la utilidad de cada uno de los métodos de ordenamiento.

 Establecer la eficiencia de cada método de ordenamiento.
 Comprobar cuál es el mejor de los métodos.

1. Se documentará la práctica.
2. Se presentará el algoritmo de operación y la prueba de escritorio.
INSTRUCCIONES
3. Se solicitará la codificación en un lenguaje de programación.
4. Se realizará pruebas para determinar el correcto
funcionamiento del programa.
INFORME

1. Marco Teórico
MÉTODOS DE ORDENAMIENTO

Los métodos de ordenación se dividen según el lugar en donde los elementos a ordenar se
encuentren dentro de la memoria principal o externa (internos o externos). Se dividen en dos
subgrupos; sin embargo, para la presenta práctica se hizo uso de uno sólo, el Método Directo –
Burbuja.

Métodos Directos
Generalmente son métodos de ordenamiento de datos utilizados cuando la data objetivo es de un
tamaño pequeño, y casi siempre son de mayo lentitud.

Método de ordenación – BURBUJA

Se lo denomina método de la burbuja pues que los valores dentro de una secuencia de datos
suben de forma gradual (burbujean) hacia la parte superior de este arreglo, y de modo simultáneo
los elementos de mayor valor bajan a la parte inferior del mismo.

Características principales:
 Busca los números más grandes en primer lugar.
 La comparación realiza lo hace con el dato vecino.
Técnica implementada:
Consiste en hacer varias pasadas a través del array; en cada una de estas se compara en
parejas conjuntas de elementos; si ambos valores se encuentran de forma creciente (o
iguales) no se modifica su posición; sin embargo, si están de forma decreciente, las
posiciones de los valores se intercambian dentro del arreglo.
Método de ordenación – SELECCIÓN
Se basa en seleccionar la posición del elemento más pequeño del arreglo y así colocarlo en la
posición que le corresponde ordenadamente. El algoritmo de selección se apoya en iteraciones
sucesivas pasadas que intercambian el elemento más pequeño sucesivamente con el primer
elemento de la lista. En la primera lectura se busca el elemento más pequeño de la lista y se
intercambia con el primer elemento de la lista. Una vez terminada esta primera lectura, el frente
de la lista está ordenado y el resto de la lista aún permanece desordenado después de este primer
elemento.

Método de ordenación –INSERCIÓN

Es una manera natural de ordenar para el ser humano, y puede usarse fácilmente para ordenar un
mazo de cartas numerada arbitrariamente.

El algoritmo consiste en ir insertando un elemento de una lista o un arreglo en la parte ordenada

del mismo, asumiendo que el primer elemento es la parte ordenada, el algoritmo ira comparando
un elemento de la parte desordenada de la lista con los elementos de la parte ordenada,
insertando el elemento en la posición correcta dentro de la parte ordenada, y así sucesivamente
hasta obtener la lista ordenada.

Método de ordenación –SHELL

El algoritmo Shell es una mejora de la ordenación por inserción, donde se comparan elementos
distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos,
el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se
encuentran cercanos, o lejanos.

Es un método adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es
aceptable y su codificación es sencilla. Su velocidad depende de la secuencia de valores con los
cuales trabaja.

Método de ordenación –QUICKSORT

Es una de las técnicas de ordenamiento más eficientes a utilizar y la mayoría de casos es precisa
para ordenar. Para hacer uso del algoritmo se deben tomar las siguientes consideraciones:

1. Elegir un elemento de la lista o arreglo, al que se le llamará pivote.

2. Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado
queden todos los menores que él, y al otro los mayores. En este momento, el pivote ocupa
exactamente el lugar que le corresponderá en la lista ordenada.
3. La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del
pivote, y otra por los elementos a su derecha.
4. Se repite el proceso con dad una de las sublistas eligiendo un pivote con el fin de ir ordenando
ambas sublistas y finalizar el ordenamiento.

Algo clave a mencionar, es que la eficiencia de éste algoritmo depende de la posición en la que
termine el pivote.
2. Desarrollo de la práctica (Uso del algoritmo, pruebas de escritorio, ejecución, captura de
pantallas).

MÉTODO BURBUJA
EJERCICIO A IMPLEMENTAR:
i j Lista[j] Lista[j+1] temp Lista[j] Lista[j+1] lista
Lista: 4 3 2 5 1
TAM = 5 1 0 4 3 4 3 4 3-4-2-5-1
1 4 2 4 2 4 3-2-4-5-1
Algoritmo a implementar:
2 4 5 3-2-4-5-1
3 5 1 5 1 5 3-2-4-1-5
2 0 3 2 3 2 3 2-3-4-1-5
1 3 4 2-3-4-1-5
2 4 1 4 1 1 2-3-1-4-5
3 4 5 2-3-1-4-5
3 0 2 3 2-3-1-4-5
1 3 1 3 1 3 2-1-3-4-5
2 3 4 2-1-3-4-5
3 4 5 2-1-3-4-5
4 0 2 1 2 1 2 1-2-3-4-5
1 1 2 1-2-3-4-5
2 2 3 1-2-3-4-5
3 4 5 1-2-3-4-5

ALGORITMO IMPLEMENTADO
/*
Materia: Estructura de Datos
Curso: Grupo 2
Carrera: Ingeniería en Computación
Autor: Alexis Roberto Vallejo Guaipatín
Fecha: 28/03/2020

PRÁCTICA DE LABORATORIO 01: MÉTODOS DE ORDENACIÓN – BURBUJA

*/
#include <iostream>
#include <array>
#include <iomanip>
using namespace std;

int main(){

int i,j;
const size_t TAM = 5;
int temp = 4;
array< int, TAM > lista = { 4, 3, 2, 5, 1 };
cout << "\t\t\tPRÁCTICA DE LABORATORIO 01"<<endl;
cout<< "\t\t\tMétodoS ordenación - Burbuja\n\n";
cout<<"Lista: ";

for(int n=0; n<TAM; n++){

cout<< lista[n]<<" ";
}
cout << endl;
cout <<"TAM = "<<TAM<<endl;
 cout <<"\ni"<< setw( 5 )<<"j"<<setw( 13 )<<"lista[j]"<<setw( 13
)<<"lista[j+1]"<<setw( 7 )<<"temp"<<setw( 13 )<<"lista[j]";
cout <<setw( 13 )<<"lista[j+1]"<<setw( 13 )<<"lista\n"<<endl;

for (i=1; i<TAM; i++ ){

cout<<i;

for (j=0 ; j<TAM-1; j++){

if (lista[j+1] < lista[j]){

temp = lista[j];
lista[j] = lista[j+1];
lista[j+1] = temp;
}

cout<<setw(5)<<j<< setw( 13 )<<lista[j]<<setw( 13

)<<lista[j+1]<<setw( 7 )<<temp<<setw( 13 )<<lista[j];
cout<<setw( 13 )<<lista[j+1]<<setw( 13 )<<setw( 7);
for(int n=0; n<TAM; n++){

cout<< lista[n]<<" ";

}
cout << endl;
}
cout<<endl;
}
return 0;
}

CAPTURA DE PANTALLA (Prueba de escritorio):

 MÉTODO DE SELECCIÓN
EJERCICIO A IMPLEMENTAR:

Lista: { 50 20 40 80 30 }
TAM = 5
Prueba de escritorio
i num Lista[i] a Lista[a] Lista[a+1] Lista

1 20 20 0 50 50 50-50-40-80-30

-1 20 20-50-40-80-30

2 40 40 1 50 50 20-50-50-80-30

0 20 40 20-40-50-80-30

3 80 80 2 50 80 20-40-50-80-30

4 30 30 3 80 80 20-40-50-80-80

2 50 50 20-40-50-50-80

1 40 40 20-40-40-50-80

0 20 30 20-30-40-50-80

ALGORITMO IMPLEMENTADO
/*
Materia: Estructura de Datos
Curso: Grupo 2
Carrera: Ingeniería en Computación
Autor: Alexis Roberto Vallejo Guaipatín
Fecha: 03/04/2020

PRÁCTICA DE LABORATORIO 03: MÉTODOS DE ORDENACIÓN – INSERCIÓN

*/

#include <iostream>
#include <array>

using namespace std;

int main(){

int i,j,n;
const size_t TAM = 5;
int num = 0;
int a = 0;
array< int, TAM > lista = { 50, 20, 40, 80, 30 };
cout << "\t\t\t\t\tEJERCICIO: Ordenación por Selección\n\n";
cout<<"Lista: { ";
for(j=0;j<TAM;j++){
cout<<lista[j]<<" ";
}
cout<<"}"<<endl;

for(i=1;i<TAM;i++){

num=lista[i];
a=i-1;
while(a>=0&&lista[a]>num){
 lista[a+1]=lista[a];
a--;
}
lista[a+1]=num;
}

cout<<"\nLista ordenada: { ";

for(n=0;n<TAM;n++){
cout<<lista[n]<<" ";
}
cout<<"}"<<endl;

return 0;
}

CAPTURA DE PANTALLA (Prueba de escritorio):

MÉTODO DE INSERCIÓN
EJERCICIO A IMPLEMENTAR:

Lista: 50 20 40 80 30
TAM = 5

i num Lista[i] a Lista[a] Lista[a+1] Lista

1 20 20 0 50 50

-1 20 20-50-40-80-30

2 40 40 1 50 50 20-50-50-80-30

0 20 40 20-40-50-80-30

3 80 80 2 50 80 20-40-50-80-30

4 30 30 3 80 80 20-40-50-80-80

2 50 50 20-40-50-50-80

1 40 40 20-40-40-50-80

0 20 30 20-30-40-50-80
ALGORITMO IMPLEMENTADO:

/*
Materia: Estructura de Datos
Curso: Grupo 2
Carrera: Ingeniería en Computación
Autor: Alexis Roberto Vallejo Guaipatín
Fecha: 03/04/2020

PRÁCTICA DE LABORATORIO 03: MÉTODOS DE ORDENACIÓN – INSERCIÓN

*/

#include <iostream>
#include <array>

using namespace std;

int main(){

int i,j,n;
const size_t TAM = 5;
int num = 0;
int a = 0;
array< int, TAM > lista = { 50, 20, 40, 80, 30 };
cout << "\t\t\t\t\tEJERCICIO: Ordenación por Selección\n\n";
cout<<"Lista: { ";
for(j=0;j<TAM;j++){
cout<<lista[j]<<" ";
}
cout<<"}"<<endl;

for(i=1;i<TAM;i++){

num=lista[i];
a=i-1;
while(a>=0&&lista[a]>num){

lista[a+1]=lista[a];
a--;
}
lista[a+1]=num;
}

cout<<"\nLista ordenada: { ";

for(n=0;n<TAM;n++){
cout<<lista[n]<<" ";
}
cout<<"}"<<endl;

return 0;
}
CAPTURA DE PANTALLA (Prueba de escritorio):

MÉTODO DE SHELL
EJERCICIO A IMPLEMENTAR:

Lista: { 45 27 53 17 73 56 49 19}
TAM: 8

Algoritmo a implementar
Prueba de escritorio:

Inst band i inst+i lista [i] lista[i+inst] aux lista [i] lista[i+inst] Lista

4 true 0 4 45 73 45-27-53-17-73-56-49-19

false 1 5 27 56 45-27-53-17-73-56-49-19

false 2 6 53 49 53 49 53 45-27-49-17-73-56-53-19

false 3 7 17 19 45-27-49-17-73-56-53-19

2 true 0 2 45 49 45-27-49-17-73-56-53-19

false 1 3 27 17 27 17 27 45-17-49-27-73-56-53-19

false 3 5 27 56 45-17-49-27-73-56-53-19

false 4 6 73 53 73 53 73 45-17-49-27-53-56-73-19

false 5 7 56 19 56 19 56 45-17-49-27-53-19-73-56

1 true 0 1 45 17 45 17 45 17-45-49-27-53-19-73-56

false 1 2 45 49 17-45-49-27-53-19-73-56

false 2 3 49 27 49 27 49 17-45-27-49-53-19-73-56

false 3 4 49 53 17-45-27-49-53-19-73-56

false 4 5 53 19 53 19 53 17-45-27-49-19-53-73-56

false 5 6 53 73 17-45-27-49-19-53-73-56

false 6 7 73 56 73 56 73 17-45-27-49-19-53-56-73

1 true 0 1 17 45 17-45-27-49-19-53-56-73

false 1 2 45 27 45 27 45 17-27-45-49-19-53-56-73

false 2 3 45 49 17-27-45-49-19-53-56-73

false 3 4 49 19 49 19 49 17-27-45-19-49-53-56-73

false 4 5 49 53 17-27-45-19-49-53-56-73

1 true 0 1 17 27 17-27-45-19-49-53-56-73

false 1 2 27 45 17-27-45-19-49-53-56-73

false 2 3 45 19 45 19 45 17-27-19-45-49-53-56-73

1 true 0 1 17 27 17-27-19-45-49-53-56-73

false 1 2 27 19 27 19 27 17-19-27-45-49-53-56-73

false 2 3 19 27 17-19-27-45-49-53-56-73
ALGORITMO IMPLEMENTADO:

/*
Materia: Estructura de Datos
Curso: Grupo 2
Carrera: Ingeniería en Computación
Autores: Alexis Vallejo Guaipatín
Bryton Rivera
Fecha: 10/04/2020
Trabajo de exposición: MÉTODOS DE ORDENACIÓN – SHELL

*/
#include <iostream>
using namespace std;

void imprimir(int [], int );

void Shell(int [], int );

int main(){

cout << "\t\t\t\t\tEJERCICIO: Ordenación SHELL\n\n";

int TAM;
cout<<"Ingrese el tamaño del arreglo: ";
cin>>TAM;
int lista[TAM];
cout<<"\nIngreso de los elementos del arreglo:\n"<<endl;
for(int i=0; i<TAM; i++){
cout<<"Ingrese el valor en la posición ["<<i+1<<"] = ";
cin>>lista[i];
}
cout<<endl;
system("pause");
system("cls");

cout << "\t\t\t\t\tEJERCICIO: Ordenación SHELL\n\n";

cout<<"LISTA SIN ORDENAR\n"<<endl;
imprimir(lista,TAM);
Shell(lista,TAM);
cout<<"\n\nLISTA ORDENADA\n"<<endl;
imprimir(lista,TAM);

return 0;
}

void Shell(int lista[], int TAM){

int inst,i,aux; //ints= variable que guarda las particiones; i=variable de

control; aux=variable que guarda el elemento
bool band; // variable que me servirá como bandera

inst=TAM;

while (inst>1){
inst=inst/2;
band =true;
while(band == true){

band= false;
i=0;
while((i+inst)<=TAM){
 if (lista[i]>lista[i+inst]){
aux = lista[i];
lista[i] = lista[i+inst];
lista[i+inst]=aux;
band = true;
}
i++;
}
}
}
}

void imprimir(int lista[], int TAM){

cout<<"Lista: {";
for(int i=0; i<TAM; i++){

cout<<" "<<lista[i];
}
cout<<" }";
}

CAPTURA DE PANTALLA (Prueba de escritorio):

 MÉTODO DE QUICKSORT
EJERCICIO A IMPLEMENTAR:

Lista: 50 20 40 80 30
TAM = 5

ALGORITMO IMPLEMENTADO:

/*
Materia: Estructura de Datos
Curso: Grupo 2
Carrera: Ingeniería en Computación
Autor: Alexis Roberto Vallejo Guaipatín
Fecha: 17/04/2020

METODO DE ORDENAMIENTO - QUICKSORT

*/

#include <iostream>
#include <iomanip>
#define largo 100
#include "leercadena.h"
using namespace std;
void quicksort(int A[],int izq, int der )
{
int i, j, x , aux=0;
i = izq;
j = der;
x = A[ (izq + der) /2 ];
cout<<"\n_________________________________________________________"<<endl;
cout<<"\tPRUEBA DE ESCRITORIO\n";
cout<<"Pivote"<<setw( 5 )<<"i"<<setw( 5 )<<"j"<<setw( 8 )<<"A[i]"<<setw( 8
)<<"A[j]"<<setw( 8 )<<"Lista"<<endl;
cout<<setw(6)<<x<<setw( 5 )<<i<<setw( 5 )<<j<<setw( 8 )<<A[i]<<setw( 8
)<<A[j]<<setw( 8 );
for(int n=0;n<der+1;n++)
{
cout<<A[n]<<" ";
}
cout<<endl;

do{
cout<<setw(6)<<x;
while( (A[i] < x) && (j <= der) )
{
i++;
cout<<setw( 5 )<<i;
}

while( (x < A[j]) && (j > izq) )

{
j--;
cout<<setw( 5 )<<j;
}
if( izq < j ){
cout<<"\n_________________________________________________________"<<endl;
cout<<"\tNUEVA SUBLISTA IZQUIERDA";
quicksort( A, izq, j );
}

if( i < der ) {

cout<<"\n_________________________________________________________"<<endl;
cout<<"\tNUEVA SUBLISTA DERECHA";
quicksort( A, i, der );
}

int main ()
{
int A[largo],n;

cout<<"\t\tMETODO DE ORDENAMIENTO - QUICKSORT\n"<<endl;

do{
cout<<"Dimension del arreglo: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a "<<largo<<endl;
}while(n<=0||n>largo);
cout<<"_______________________________________"<<endl;
cout<<"Ingreso de datos del arreglo\n"<<endl;
leeCadena(n,A);
system("pause");
system("cls");
cout<<"\t\tMETODO DE ORDENAMIENTO - QUICKSORT"<<endl;
quicksort(A,0,n-1);
cout<<"_______________________________________"<<endl;
cout<<"Arreglo ordenado: ";
muestraCadena(n,A);

return 0;

#include<iostream>
using namespace std;
void leeCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<"Ingresa numero de la posicion ["<<i+1<<"]: ";
cin>>n[i];
}
cout<<endl;
}

void muestraCadena(int cant,int n[])

{
int i;
for(i=0;i<cant;i++)
{
cout<<n[i]<<" ";
}
cout<<endl;
}
CAPTURA DE PANTALLA (Prueba de escritorio):
3. Recursos utilizados.

- Computadora portátil
- Material descargable del AVAC: Cap. 1 Métodos de Ordenación.pdf
- Programa Dev – C++

RESULTADO(S) OBTENIDO(S):

En cada uno de los métodos de ordenación implementados, se efectuó con éxito rotundo, permitiendo
evaluar la eficiencia de cada uno; además, estos resultados permitieron en cierta medida comparar la
comparación de una técnica con otra. Por así decirlo durante la codificación de cada uno fue posible
también determinar la complejidad de un método con otro. Todo lo mencionado se puede verificar en el
desarrollo de la presente práctica en el literal número 2.

CONCLUSIONES:

1. Sin duda cada uno de los métodos tiene su complejidad, sin embargo, hay uno que sobresale de entre
todos, el método quicksort, es el que destaca en cuanto a velocidad y cantidad de manipulación de
datos, a pesar de que su codificación compleja.
2. Es clave dentro de la construcción del algoritmo que la construcción del arreglo esté bien hecha, pues
sino esto representará un error más a futuro durante la compilación del mismo.
3. El propósito principal de una técnica de ordenamiento es facilitar las búsquedas de un determinado
elemento dentro de un conjunto ordenado.
4. El método para ordenar datos que no tienen mucha complejidad es el de ordenamiento por burbuja,
pero si los datos están totalmente desordenados y son altamente complejos, lo mejor es utilizar el
método quicksort.

RECOMENDACIONES:

1. El practicante deberá tener conocimiento suficiente en el manejo de arrays, implementación de los

mismos y operaciones con ellos, incluso la declaración, ya que de esto depende el éxito de la
elaboración de un código de programación, el cual cumpla con los requerimientos de la práctica.
2. El practicante deberá tener una concentración tal que permita identificar errores posibles en el código, o
incluso que permita implementar el algoritmo para que éste en el momento de compilar tenga el
mínimo de errores, e incluso que se propenda al éxito total de la ejecución de la práctica.
3. Es importante saber qué tipo de método utilizar para el ordenamiento, debido a que si es necesario
ordenar pocos datos el algoritmo a usar será el que ocupe menos espacio de memoria.

BIBLIOGRAFÍA:

- C algoritmos, programación y estructuras de datos.

Autor: Joyanes Aguilar, Luis Castillo Sanz, Andrés Sánchez García, Lucas
- http://lwh.free.fr/pages/algo/tri/tri_insertion_es.html
- http://lwh.free.fr/pages/algo/tri/tri_rapide_es.html
- https://www.ecured.cu/Algoritmo_de_Ordenamiento_Shell
- http://hilite.me

Msc. Walter Gaibor:

Firma: