Sunteți pe pagina 1din 22

FACULTAD DE INGENIERÍA

CARRERA:
Ingeniería de Sistemas Computacionales
CURSO:
FUNDAMENTOS DE PROGRAMACIÓN
DOCENTE:
 Malpica Rodríguez, Manuel Enrique
ALUMNO:
 Guerrero Cardozo, José
 Huaripata Piminchumo, Miguel
 Minchan Huamán, Yan Medardo
 Vergara Sánchez, Marcelo
CLASE: 2184135197
CICLO: III

Cajamarca-Perú
2018
Tabla de contenido
I. INTRODUCCIÓN Y OBJETIVOS ......................................................................................... 3
1.1. INTRODUCCIÓN: ............................................................................................................... 3
1.2. OBJETIVOS:......................................................................................................................... 3
II. DESARROLLO ..................................................................................................................... 3
2.1. INFORMACIÓN TEÓRICA ............................................................................................... 3
2.1.1. ORDENAMIENTO ........................................................................................................... 3
2.1.2. METRODOS DE ORDENAMIENTO ............................................................................ 3
2.1.2.1. METODO DE ORDENAMIENTO MARGE ............................................................. 4
2.1.2.1.1. ALGORITMO ............................................................................................................... 4
EJEMPLO: ........................................................................................................................................ 4
2.1.2.1.2. PSEUDOCÓDIGO ..........................................................Error! Bookmark not defined.
2.1.2.1.3. CODIGO C++ ................................................................................................................ 8
2.1.2.2. METODO DE ORDENAMIENTO SHELL ............................................................... 9
2.1.2.2.1. CONCEPTO ................................................................................................................ 10
2.1.2.2.2. DIAGRAMA DE FLUJO ........................................................................................... 11
2.1.2.2.3. CODIGO C++ .............................................................................................................. 12
2.1.2.3. METODO DE ORDENAMIENTO QUICKSORT .................................................. 13
2.1.2.4. CONCEPTO Y EJEMPLO: ....................................................................................... 13
EJEMPLO ....................................................................................................................................... 13
DIAGRAMA DE FLUJO ............................................................................................................... 14
2.1.2.4.1. CODIGO C++ .............................................................................................................. 17
3.1.1. VIDEO: ............................................................................................................................ 18
IV. CONCLUSIONES ............................................................................................................... 19
FUENTES DE REFERENCIA ...................................................................................................... 22
BIBLIOGRAFIA ............................................................................................................................. 22
I. INTRODUCCIÓN Y OBJETIVOS
1.1. INTRODUCCIÓN:

El presente proyecto académico, presenta los métodos de ordenamiento como


Marge, Shell y QuickSort los cuales serán muy útiles a lo largo del desarrollo de
nuestro ciclo académico y carrera en general. En cada método de ordenamiento
está documentado su algoritmo, también su seudocódigo o diagrama de flujo o
diagrama N-S de tal forma que nuestro proyecto elaborado sea más interactivo.

Así mismo, para realizar los ejercicios de métodos de ordenamiento, hemos utilizado
una herramienta llamada Zinjai; este programa trabaja con el lenguaje de
programación C++. Finalmente, el proyecto tendrá algunos puntos importantes en
la documentación, tales como: una introducción, objetivos, información teórica, un
vídeo explicando (algoritmo, pseudocódigo y código c++) de un problema elegido
por nosotros y conclusiones.

1.2. OBJETIVOS:

 Implantar los conocimientos obtenidos durante el desarrollo del curso, y así,


reflejar todo lo aprendido mediante el proyecto de programación.

 Investigar y aprender nuevos conocimientos sobre la programación para tener


mayores facilidades a la hora de resolver nuestro proyecto y ciertos algoritmos.

 Presentar, a nuestro docente y compañeros un buen proyecto haciendo uso de


las herramientas: Zinjai y Pseint.

II. DESARROLLO
2.1. INFORMACIÓN TEÓRICA
2.1.1. ORDENAMIENTO
Un ordenamiento es una suma de elemento dispuestos de una determinada manera para
lograr la consecución de un fin determinado. De esta definición aplicable a múltiples
contextos la asociación más relevante y recurrente es la que hace referencia al conjunto de
normas y leyes que sirven a una sociedad determinada para su desenvolvimiento. Así, un
ordenamiento jurídico da cuenta de una secuencia de normas estructuradas en distinta
jerarquía que sirven para poner reglas y organización en una sociedad. Estas normas se
conciben como un sistema, es decir que mantienen relaciones las unas con las otras de un
modo orgánico y con una lógica fácilmente comprensible.

2.1.2. METRODOS DE ORDENAMIENTO


“Ordenación, búsqueda y, en menor medida, intercalación son operaciones básicas en el campo
de la documentación y en las que, según señalan las estadísticas, las computadoras emplean la
mitad de su tiempo” Joyanes, L. (2008). p. 352.
En computación y matemáticas un algoritmo de ordenamiento es un algoritmo que pone
elementos de una lista o un vector en una secuencia dada por una relación de orden, es
decir, el resultado de salida ha de ser una permutación —o reordenamiento— de la entrada
que satisfaga la relación de orden dada. Las relaciones de orden más usadas son el orden
numérico y el orden lexicográfico. Ordenamientos eficientes son importantes para optimizar
el uso de otros algoritmos (como los de búsqueda y fusión) que requieren listas ordenadas
para una ejecución rápida. También es útil para poner datos en forma canónica y para
generar resultados legibles por humanos.

2.1.2.1. METODO DE ORDENAMIENTO MARGE

2.1.2.1.1. ALGORITMO
En los ordenadores modernos, el principio de localidad puede ser primordial en la
optimización de software, porque se usan jerarquías de memoria multi-nivel. Se han
propuesto versiones de cache-consciente del algoritmo de ordenación por mezcla, cuyas
operaciones han sido específicamente escogidas para minimizar el movimiento de entrada
y salida de páginas de la memoria caché de la máquina. Por ejemplo, el algoritmo "tiled
merge sort" deja de particionar subarrays cuando se han alcanzado subarrays de tamaño
S, donde S es el número de elementos que caben en una única página en memoria. Cada
uno de esos subarrays se ordenan con un algoritmo de ordenación in-situ, para evitar
intercambios en memoria, y entonces se termina con el algoritmo de ordenamiento por
mezcla en su versión recursiva estándar. Este algoritmo ha demostrado un mejor
rendimiento en máquinas que se benefician de la optimización caché (Kronrod, 1969).

EJEMPLO:
Este método se basa en la siguiente idea:

Si la lista es pequeña (vacía o de tamaño 1) ya está ordenada y no hay nada que hacer. De
lo contrario hacer lo siguiente:

Dividir la lista al medio, formando dos sublistas de (aproximadamente) el mismo tamaño


cada una.

Ordenar cada una de esas dos sublistas (usando este mismo método).

Una vez que se ordenaron ambas sublistas, intercalarlas de manera ordenada.

Por ejemplo, si la lista original es [6, 7, -1, 0, 5, 2, 3, 8] deberemos ordenar recursivamente


[6, 7, -1, 0] y [5, 2, 3, 8] con lo cual obtendremos [-1, 0, 6, 7] y [2, 3, 5, 8]. Si intercalamos
ordenadamente las dos listas ordenadas obtenemos la solución buscada: [-1, 0, 2, 3, 5, 6,
7, 8].

Diseñamos la función merge_sort(lista):

Si lista es pequeña (vacía o de tamaño 1) ya está ordenada y no hay nada que hacer. Se
devuelve lista tal cual.
De lo contrario:

medio = len(lista)/2

izq = merge_sort(lista[:m])

der = merge_sort(lista[m:])

Se devuelve merge(izq, der).

Falta sólo diseñar la función merge que realiza la intercalación ordenada de dos listas
ordenadas (dadas dos listas ordenadas se debe obtener una nueva lista que resulte de
intercalar a ambas de manera ordenada).

Diseñamos la función merge(lista1, lista2):

Utilizaremos dos índices, i y j, para recorrer cada una de las dos listas.

Utilizaremos una tercera lista, resultado, donde almacenaremos el resultado.

Mientras i sea menor que el largo de lista1 y j menor que el largo de lista2, significa que hay
elementos para comparar en ambas listas.

Si el menor es el de lista1: agregar el elemento i de lista1 al final del resultado. Avanzar el


índice i.

de lo contrario: agregar el elemento j de lista2 al final del resultado. Avanzar el índice j.

Una vez que una de las dos listas se termina, simplemente hay que agregar todo lo que
queda en la otra al final del resultado.

2.1.2.1.2. DIAGRAMA DE FLUJO

MÉTODO MERGESORT

FUNCIÓN main
FUNCION void Merge(int v[], int vTemp[], int posIzq, int posDer, int finDer)
FUNCION void MergeSort(int v[], int vTemp[], int izq, int der)
2.1.2.1.3. CODIGO C++
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cstddef>
using namespace std;
void GenerarVector(int v[], int n);
void MostrarVector(int v[], int n);
void MergeSort(int v[], int vTemp[], int izq, int der);
void Merge(int v[], int vTemp[], int posIzq, int posDer, int finDer);
int main(int argc, char *argv[]) {
system("color 02");
cout<<"Ingrese el numero de elementos : ";
int n;
cin>>n;
int const MAX = 50;
int v[MAX];
srand(time(NULL));
GenerarVector(v,n);
MostrarVector(v,n);
int vTemp[MAX];
MergeSort(v, vTemp, 0, n-1);
cout<<"Vector Ordenado : "<<endl;
MostrarVector(v,n);
return 0;
}
void Merge(int v[], int vTemp[], int posIzq, int posDer, int finDer){
int finIzq = posDer - 1;
int posTemp = posIzq;
int numElementos = finDer - posIzq + 1;
while(posIzq<=finIzq && posDer <= finDer){
if (v[posIzq] < v[posDer]) {
vTemp[posTemp++] = v[posIzq++];
} else {
vTemp[posTemp++] = v[posDer++];
}
}
while(posIzq <= finIzq){
vTemp[posTemp++] = v[posIzq++];
}
while(posDer <= finDer){
vTemp[posTemp++] = v[posDer++];
}
for(int i =0; i<numElementos; i++,finDer--){
v[finDer] = vTemp[finDer];
}
}
void MergeSort(int v[], int vTemp[], int izq, int der){
if(izq < der){
int centro = (izq + der)/2;
MergeSort(v, vTemp, izq, centro);
MergeSort(v, vTemp, centro+1 , der);
Merge(v, vTemp, izq, centro+1, der);
}
}
void GenerarVector(int v[], int n){
for (int i=0;i<n;i++) {
v[i] = rand()%50;
}
}
void MostrarVector(int v[], int n){
cout<<endl;
for (int i=0;i<n;i++) {
cout<<v[i]<<"\t";
}
cout<<endl;
}

2.1.2.2. METODO DE ORDENAMIENTO SHELL


“El método se denomina “Shell” —en honor de su inventor Donald Shell— y también
método de inserción con incrementos decrecientes. En el método de clasificación por inserción cada
elemento se compara con los elementos contiguos de su izquierda, uno tras otro”. Joyanes, L.
(2008). p.370.

El algoritmo Shell es una mejora de la ordenación por inserción, donde se van


comparando 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 bastante
adecuado para ordenar listas de tamaño moderado, debido a que su velocidad es aceptable
y su codificación es bastante sencilla. Su velocidad depende de la secuencia de valores
con los cuales trabaja, ordenándolos. El siguiente ejemplo muestra el proceso de forma
gráfica. Considerando un valor pequeño que está inicialmente almacenado en el final del
vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento
por inserción, tomará aproximadamente n comparaciones e intercambios para mover este
valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando
tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes
posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios
(Pratt, 1979).

2.1.2.2.1. CONCEPTO
Algoritmo de ordenamiento Shell: El método se denomina así en honor de su
inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e
intercambios en el peor caso, aunque 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). El Shell sort es una generalización del ordenamiento por inserción,
teniendo en cuenta dos observaciones: El ordenamiento por inserción es eficiente si la
entrada está "casi ordenada". El ordenamiento por inserción es ineficiente, en general,
porque mueve los valores sólo una posición cada vez. El algoritmo Shell sort mejora el
ordenamiento por inserción comparando elementos separados por un espacio de varias
posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición
esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez
más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero
para entonces, ya está garantizado que los datos del vector están casi ordenados.

Ejemplo

Por ejemplo, considere una lista de números como [13 14 94 33 82 25 59 94 65 23 45 27


73 25 39 10]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto
dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así:

Entonces ordenamos cada columna, lo que nos queda:

Cuando lo leemos de nuevo como una única lista de números, obtenemos [ 10 14 73 25 23


13 27 94 33 39 25 59 94 65 82 45]. Aquí, el 10 que estaba en el extremo final, se ha movido
hasta el extremo inicial.
Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3
posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por
inserción simple).

2.1.2.2.2. DIAGRAMA DE FLUJO

METODO SHELLE

FUNCION MAIN

FUNCION void Shell(int v[], int n)


2.1.2.2.3. CODIGO C++
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int const MAX=100;
void Generar(int v[],int n);
void Mostrar(int v[],int n);
void Shell(int v[], int n);
int main(int argc, char *argv[]) {
system("color 02");
cout <<"ingresa el nuemro de elementos: ";
int n;
cin >>n;
int v[MAX];
Generar(v,n);
Mostrar(v,n);
Shell(v,n);
cout<<"\n";
cout<<"Vector Ordenado : "<<endl;
Mostrar(v,n);
return 0;
}
void Shell(int v[], int n){
for(int salto = n/2; salto>0; salto /= 2){
for(int i = salto; i<n; i++){
int temp = v[i];
int j;
for(j=i; j>=salto && temp < v[j-salto];j -= salto){
v[j] = v[j-salto];
}
v[j] = temp;
}
}
}

void Generar(int v[],int n){


srand(time(NULL));
for (int i=0;i<n;i++) {
v[i]=rand()%20;
}
}
void Mostrar(int v[],int n){
cout <<endl;
for (int i=0;i<n;i++) {
cout <<v[i]<<"\t";
}
cout <<endl;
}

2.1.2.3. METODO DE ORDENAMIENTO QUICKSORT


2.1.2.4. CONCEPTO Y EJEMPLO:
El ordenamiento rápido (Quicksort en inglés) es un algoritmo basado en la técnica de divide
y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n
log n. Esta es la técnica de ordenamiento más rápida conocida. Fue desarrollada por C.
Antony R. Hoare en 1960. El algoritmo original es recursivo, pero se utilizan versiones
iterativas para mejorar su rendimiento (los algoritmos recursivos son en general más lentos
que los iterativos, y consumen más recursos).

EJEMPLO

En el siguiente ejemplo se marcan el pivote y los índices i y j con las letras p, i y j


respectivamente.

Comenzamos con la lista completa. El elemento pivote será el 4:

5-3-7-6-2-1-4

Comparamos con el 5 por la izquierda y el 1 por la derecha.

5-3-7-6-2-1-4

i j p

5 es mayor que 4 y 1 es menor. Intercambiamos:


1-3-7-6-2-5-4

i j p

Avanzamos por la izquierda y la derecha:

1-3-7-6-2-5-4

i j p

3 es menor que 4: avanzamos por la izquierda. 2 es menor que 4: nos mantenemos ahí.

1 -3 - 7 - 6 - 2 - 5 - 4

i j p

7 es mayor que 4 y 2 es menor: intercambiamos.

1-3-2-6-7-5-4

i j p

Avanzamos por ambos lados:

1-3-2-6-7-5-4

Iyj p

En este momento termina el ciclo principal, porque los índices se cruzaron. Ahora
intercambiamos lista[i] con lista[p] (pasos 16-18):

1-3-2-4-7-5-6

Aplicamos recursivamente a la sublista de la izquierda (índices 0 - 2). Tenemos lo siguiente:

1-3-2

1 es menor que 2: avanzamos por la izquierda. 3 es mayor: avanzamos por la derecha.


Como se intercambiaron los índices termina el ciclo. Se intercambia lista[i] con lista[p]:

1-2-3

El mismo procedimiento se aplicará a la otra sublista. Al finalizar y unir todas las sublistas
queda la lista inicial ordenada en forma ascendente.

1-2-3-4-5-6-7

DIAGRAMA DE FLUJO

METODO QUICKSORT
FUNCION MAIN
FUNCION void QuickSort(int v[], int izq, int der)
2.1.2.4.1. CODIGO C++
#include <iostream>
#include <cstdlib>
#include <ctime>
int const MAX=200;
using namespace std;
void GenerarV(int v[], int n);
void MostrarV(int v[], int n);
void QuickSort(int v[], int izq, int der);
int main(int argc, char *argv[]) {
system("color 02");
srand(time(NULL));
cout<<"Ingrese cantidad de elementos: ";
int n;
cin>>n;
int v[MAX];
GenerarV(v,n);
MostrarV(v,n);
cout<<endl<<endl;
QuickSort(v,0,n-1);
cout<<endl;
cout<<"Vector Ordenado : "<<endl;
MostrarV(v,n);
return 0;
}
void QuickSort(int v[], int izq, int der){
int i = izq;
int j = der;
int pivote = v[(izq+der)/2];
do{
while(v[i] < pivote) i++;
while(v[j] > pivote) j--;
if (i <= j){
int aux = v[i];
v[i] = v[j];
v[j] = aux;
i++;
j--;
}
}while(i <= j);
if (izq < j) QuickSort(v,izq,j);
if (i < der) QuickSort(v,i,der);
}

void GenerarV(int v[], int n){


for (int i=0; i<n; i++){
v[i]=rand()%50;
}
}

void MostrarV(int v[], int n){


cout<<endl;
for (int i=0; i<n; i++){
cout<<v[i]<<"\t";
}
cout<<endl;
}
III.

3.1.1. VIDEO:

VIDEO 1: Intercambio de dos valores en C++


IV. CONCLUSIONES

 Como resultado de la investigación teórica, hemos aprendido a mejorar nuestro


aprendizaje autónomo, debido a los factores principales; primero, hemos buscado
información; segundo, hemos identificado y evaluado la información; por último,
hemos extraído y utilizado eficazmente, información contenida en diferentes
fuentes para satisfacer el tema buscado y adquirir un nuevo conocimiento de
aprendizaje.

 A lo largo del desarrollo del proyecto de programación, nos hemos dado cuenta
que podemos dar solución a muchos problemas mediante programas (Software);
aplicando la tan conocida frase “Divide y vencerás” ya que para desarrollar los
métodos de ordenamiento se aplica esa teoría.

 Finalmente, después de haber culminado el proyecto de programación basándose


en los métodos de ordenamiento, primero se tiene que hacer un análisis, luego
implementarlo y finalmente comprobar si funciona correctamente el programa

FICHAS TEXTUALES

Autor: Luis Joyanes Aguilar. Editorial:


Título: FUNDAMENTOS McGrawHill
DE PROGRAMACIÓN Ciudad:
Algoritmos, estructura Madrid,
de datos y objetos España
Año: 2008

Tema: Orden, búsqueda he inserción


p.356
“Ordenación, búsqueda y, en menor medida,
intercalación son operaciones básicas en el campo
de la documentación y en las que, según señalan las
estadísticas, las computadoras emplean la mitad de
su tiempo”.
4° edición Ficha n° 1
Autor: Paul J. Deitel Y Harvey M.
Deitel. Editorial:
Pearson.
Título: Como programar en java.
Ciudad:
Año: 2014 México
Tema: Ordenamiento
p.703
El ordenamiento por el método de Merge es un
algoritmo de ordenamiento eficiente, pero en
concepto es más complejo que los ordenamientos de
selección y de inserción. Para ordenar un arreglo, el
algoritmo de ordenamiento Merge lo divide en dos
subarreglos de igual tamaño, ordena cada subarreglo
y después los combina en un arreglo más grande.

9° edición Ficha N°2

Autor:
Luis Joyanes Aguilar.
Título: FUNDAMENTOS
DE PROGRAMACIÓN
Algoritmos, estructura Editorial: McGrawHill
de datos y objetos Ciudad: Madrid, España
Año:2008
Tema: métodos de ordenamiento
p.57
Shell es una mejora del método de inserción
directa que se utiliza cuando el número de
elementos a ordenar es grande. El método se
denomina “Shell” —en honor de su inventor Donald
Shell— y también método de inserción con
incrementos decrecientes. En el método de
clasificación por inserción cada elemento se
compara con los elementos contiguos de su
izquierda, uno tras otro.
1° edicion Ficha n° 4

Autor: Mionica Garcia Obtenido de


Título: Arreglos http://www.utm.mx/~mgarcia
Año: 2013 Ciudad: México
Tema: métodos de ordenamiento
Pag. 7-9
El algoritmo Shell sort mejora el ordenamiento por
inserción comparando elementos separados por un
espacio de varias posiciones. Esto permite que un
elemento haga "pasos más grandes" hacia su posición
esperada. Los pasos múltiples sobre los datos se hacen
con tamaños de espacio cada vez más pequeños. El
último paso del Shell sort es un simple ordenamiento
por inserción, pero para entonces, ya está garantizado
que los datos del vector están casi ordenados
4° Modulo Ficha N° 5
Autor: Editorial: McGrawHill
Luis Joyanes Aguilar. Ciudad: Madrid, España
Título: FUNDAMENTOS
DE PROGRAMACIÓN
Algoritmos, estructura
de datos y objetos
Año:2008
Tema: Orden, búsqueda he inserción
p.370
Quicksort El método de ordenación rápida para
ordenar o clasificar un vector o lista de elementos
(array) se basa en el hecho de que es más rápido y
fácil de ordenar dos listas pequeñas que una lista
grande. Se denomina método de ordenación
rápida porque, en general, puede ordenar una lista
de datos mucho más rápidamente que cualquiera
de los métodos de ordenación ya estudiados
4° edicion Ficha N° 6

FUENTES DE REFERENCIA

BIBLIOGRAFÍA
Deitel, P., & Deitel, H. (2014). Como programar en C++ (Novena ed.). México: Pearson.
Garcia, M. (s.f.). Arreglos. Obtenido de http://www.utm.mx/~mgarcia/PE4(Arreglos).pdf
Joyanes, L. (s.f.). Fundamentos de Progrmación (Vol. II). Madrid, España: McGrawHill.
Joyanes, L., & Lucas, S. (2006). Programacion en c++. Madrid, España: McGraw-
Hill/Interamericana.