Documente Academic
Documente Profesional
Documente Cultură
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:
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:
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.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:
Ordenar cada una de esas dos sublistas (usando este mismo método).
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:])
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).
Utilizaremos dos índices, i y j, para recorrer cada una de las dos listas.
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.
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.
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.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
METODO SHELLE
FUNCION MAIN
EJEMPLO
5-3-7-6-2-1-4
5-3-7-6-2-1-4
i j p
i j p
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
1-3-2-6-7-5-4
i j p
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
1-3-2
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);
}
3.1.1. VIDEO:
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.
FICHAS TEXTUALES
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
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.