Trabajo Metodos de Ordenamiento

UNIVERSIDAD ANDINA DEL CUSCO
FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
Estructura de datos
SEM 2020 – I
GUIA DE APLICACIÓN Nº 01
ENTREGA DE ACTIVIDAD DE LA GUÍA N°4B MÉTODOS DE ORDENAMIENTO Inserción
Selección y Shell
Datos del estudiante
Nombre y apellidos: Reny Rodrigo Luque Rios, Ochoa Moreano Jhonatan
FECHA : 03 DE marzo de 2020
I. DATOS INFORMATIVOS:
1.1. Nombre de la asignatura : Estructura de datos
1.2. Semestre Académico : 2020 - I
1.3. Ciclo de estudios : 4°
1.4. Nombre del docente : Mtra. Ing. Lizet Vargas Vera
1.5. Grupo : A
1.6. Objetivos Educacionales : OEP1
1.7. Resultados del Estudiante : RE(a)= 1
1.8. Indicadores de desempeño: a1, a3,
II. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO INSERCION

Definición
La idea de este algoritmo de ordenación consiste en ir insertando un elemento de la lista ó un
arreglo en la parte ordenada de la misma, 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.
Declaración
Pseudocódigo
Procedimiento Insertion_Sort ( Vector A[1:N])
1
Estructura de datos
SEM 2020 – I
Sintaxis C#
void Insertion_sort(int* t)
{
int i, j;
int actual;
for (i = 1; i < 20; i++) {
actual = t[i];
for (j = i; j > 0 && t[j - 1] > actual; j--) {
t[j] = t[j - 1];
t[j] = actual;
Recorrido
Pseudocódigo
Para I Variando De 2 Hasta N Hacer
Insertar A[I] En Su Lugar En A[1:I-1];
Fin Procedimiento;
Operaciones con arreglos (Metodo De Ordenamiento Insercion)
El ordenamiento por inserción, aunque sigue siendo O(n2)O(n2), funciona de una manera ligeramente
diferente. Siempre mantiene una sublista ordenada en las posiciones inferiores de la lista. Cada ítem
nuevo se “inserta” de vuelta en la sublista previa de manera que la sublista ordenada sea un ítem más
larga. La Figura 4 muestra el proceso de ordenamiento por inserción. Los ítems sombreados representan
las sublistas ordenadas a medida que el algoritmo lleva a cabo cada pasada.
Recorrido
Consiste en ir insertando un elemento de la lista ó un arreglo en la parte ordenada de la misma,

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
Para I Variando De 2 Hasta N Hacer
Insertar A[I] En Su Lugar En A[1:I-1];
Fin Procedimiento;
1
Estructura de datos
SEM 2020 – I
III. DESARROLLO DE LA GUIA

Ejemplo 1
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere que al
final del día calcule la cantidad de dinero que hay depositada.
La Solución tendrá el siguiente esquema: Debemos definir los atributos y los métodos de cada clase:
Cliente
atributos
nombre
monto
métodos
constructor
Depositar
Extraer
RetornarMonto
4.1. DISEÑO
4.1.1. Pseudocódigo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PruebaVector
class PruebaVector
private int[] vector;
public void Cargar()
Console.WriteLine("Metodo de insercion directa");
Console.Write("Cuantos longitud del vector:");
string linea;
linea = Console.ReadLine();
int cant;
cant = int.Parse(linea);
vector = new int[cant];
1
Estructura de datos
SEM 2020 – I
for (int f = 0; f < vector.Length; f++)
Console.Write("Ingrese elemento "+(f+1)+": ");
vector[f] = int.Parse(linea);
public void InsercionDirecta()
int auxili;
int j;
for (int i = 0; i < vector.Length; i++)
auxili = vector[i];
j = i - 1;
while (j >= 0 && vector[j] > auxili)
vector[j + 1] = vector[j];
j--;
vector[j + 1] = auxili;
public void Imprimir()
Console.WriteLine("Vector ordenados en forma ascendente");
Console.Write(vector[f]+" ");
}
1
Estructura de datos
SEM 2020 – I
Console.ReadKey();
static void Main(string[] args)
PruebaVector pv = new PruebaVector();
pv.Cargar();
pv.InsercionDirecta();
pv.Imprimir();
IV. IMPLEMENTACIÓN EN UN LENGUAJE
Desarrollar la implementacion en
C#
V. REFERENCIAS BIBLIOGRÁFICAS
o Cursos Online C Sharp, Método de Ordenamiento de Inserción Directa en C#
o Algorithmique/Programmation, Ordenamiento por inserción, Français
3
Estructura de datos
SEM 2020 – I
VI. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO SELECCION

Definición
La idea de este algoritmo de ordenación consiste en ir seleccionando el menor de todos lo elementos de
una arreglo y ponerlos en una lista ordenada y esta iteración repetida por la cantidad de elementos del
arreglo definido hasta obtener una lista ordenada.
Declaración
Pseudocódigo
para i=1 hasta n-1;
minimo = i;
Sintaxis Java
Java void selecccion(int[] a) {
for (int i = 0; i < a.length - 1; i++)
int min = i;
for (int j = i + 1; j < a.length; j++)
{
if (a[j] < a[min])
{
min = j;
}
}
if (i != min)
{
int aux= a[i];
a[i] = a[min];
a[min] = aux;
}
}}
3
Estructura de datos
SEM 2020 – I
Recorrido
Pseudocódigo
para j=i+1 hasta n
si lista[j] < lista[minimo] entonces
minimo = j
fin si
fin para
intercambiar(lista[i], lista[minimo])
fin para
Operaciones con arreglos (Metodo De Ordenamiento Insercion)
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector
de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más
complejas, la operación intercambiar() sería más costosa en este caso. Este algoritmo realiza muchas
menos operaciones intercambiar() que el de la burbuja, por lo que lo mejora en algo. Si la línea
comentada con (!) se sustituyera por intercambiar(lista[i], lista[j]) tendríamos una versión del algoritmo
de la burbuja (naturalmente eliminando el orden intercambiar del final).
Otra desventaja de este algoritmo respecto a otros como el de burbuja o de inserción directa es que no
mejora su rendimiento cuando los datos ya están ordenados o parcialmente ordenados. Así como, por
ejemplo, en el caso de la ordenación de burbuja se requeriría una única pasada para detectar que el
vector ya está ordenado y finalizar, en la ordenación por selección se realizarían el mismo número de
pasadas independientemente de si los datos están ordenados o no.
.
Recorrido
Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que
está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo
para j=i+1 hasta n
si lista[j] < lista[minimo] entonces
minimo = j
fin para
intercambiar(lista[i], lista[minimo])
fin para
1
Estructura de datos
SEM 2020 – I
VII. DESARROLLO DE LA GUIA

VIII.
Ejemplo 1
q-2: suponga que usted tiene que ordenar la siguiente lista de números: [11, 7, 12, 14, 19, 1, 6, 18, 8, 20]
¿cuál de las siguientes listas representa la lista parcialmente ordenada tras tres pasadas completas del
ordenamiento por selección?
4.2. DISEÑO
def ordenamientoPorSeleccion(unaLista):
for llenarRanura in range(len(unaLista)-1,0,-1):
posicionDelMayor=0
for ubicacion in range(1,llenarRanura+1):
if unaLista[ubicacion]>unaLista[posicionDelMayor]:
posicionDelMayor = ubicacion
temp = unaLista[llenarRanura]
unaLista[llenarRanura] = unaLista[posicionDelMayor]
unaLista = [54,26,93,17,77,31,44,55,20]
ordenamientoPorSeleccion(unaLista)
print(unaLista)
IX. IMPLEMENTACIÓN EN UN LENGUAJE
Java
X. REFERENCIAS BIBLIOGRÁFICAS
o Cursos Online C Sharp, Método de Ordenamiento de Seleccion en Java
o Algorithmique/Programmation, Ordenamiento por Seleccion, Français
2
Estructura de datos
SEM 2020 – I
XI. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO SHELL

Definición
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.
Declaración
Pseudocódigo
ROCEDURE tri_Insertion ( Tableau a[1:n],gap,debut)
POUR i VARIANT DE debut A n AVEC UN PAS gap FAIRE
INSERER a[i] à sa place dans a[1:i-1];
FIN PROCEDURE;
Sintaxis C
void tri_insertion(int* t, int gap, int debut)
{
int j,en_cours;
for (int i = gap + debut; i < 20; i+=gap) {
en_cours = t[i];
for (j = i; j >= gap && t[j - gap] > en_cours; j-=gap) {
t[j] = t[j - gap];
}
t[j] = en_cours;
}
}
void tri_shell(int* t) {
int intervalles[5]={6,4,3,2,1};
3
Estructura de datos
SEM 2020 – I
for (int ngap=0;ngap<5;ngap++) {
for (int i=0;i<intervalles[ngap];i++)
tri_insertion(t,intervalles[ngap],i);
Recorrido
Pseudocódigo
PROCEDURE tri_shell ( Tableau a[1:n])
POUR gap DANS (6,4,3,2,1) FAIRE
POUR debut VARIANT DE 0 A gap - 1 FAIRE
tri_Insertion(Tableau,gap,debut);
FIN POUR;
FIN POUR;
FIN PROCEDURE;
Operaciones con arreglos (Metodo De Ordenamiento Shell)
.
Recorrido
Consiste en encontrar el menor de todos los elementos del arreglo o vector e intercambiarlo con el que
está en la primera posición. Luego el segundo mas pequeño, y así sucesivamente hasta ordenarlo todo
PROCEDURE tri_shell ( Tableau a[1:n])
POUR gap DANS (6,4,3,2,1) FAIRE
POUR debut VARIANT DE 0 A gap - 1 FAIRE
tri_Insertion(Tableau,gap,debut);
FIN POUR;
FIN POUR;
4
Estructura de datos
SEM 2020 – I
XII. DESARROLLO DE LA GUIA

XIII.
Ejemplo 1
[ 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)
4.3. DISEÑO
using System;
using System.Linq;
using System.Text;
namespace PruebaVector
{
class PruebaVector
{
private int[] vector;
public void Cargar()

{
Console.WriteLine("Metodo de Shell Sort");
Console.Write("Cuantos longitud del vector:");
string linea;
int cant;
cant = int.Parse(linea);
vector = new int[cant];
{
Console.Write("Ingrese elemento "+(f+1)+": ");
vector[f] = int.Parse(linea);
}
}
public void Shell()
{
1
Estructura de datos
SEM 2020 – I
int salto = 0;
int sw = 0;
int auxi = 0;
int e = 0;
salto = vector.Length / 2;
while (salto > 0)

{
sw = 1;
while (sw != 0)
{
sw = 0;
e = 1;
while (e <= (vector.Length - salto))
{
if (vector[e - 1] > vector[(e - 1) + salto])
{
auxi = vector[(e - 1) + salto];
vector[(e - 1) + salto] = vector[e - 1];
vector[(e - 1)] = auxi;
sw = 1;
}
e++;
}
}
salto = salto / 2;
}
}
public void Imprimir()
{
{
Console.Write(vector[f]+" ");
}
Console.ReadKey();
}
static void Main(string[] args)

{
PruebaVector pv = new PruebaVector();
pv.Cargar();
pv.Shell();
pv.Imprimir();
}
}
}
XIV. IMPLEMENTACIÓN EN UN LENGUAJE

2
Estructura de datos
SEM 2020 – I
Desarrollar la implementacion en C
XV. REFERENCIAS BIBLIOGRÁFICAS
o Cursos Online C Sharp, Método de Ordenamiento de Shell en C#
o Algorithmique/Programmation, Ordenamiento por Shell, Français
3
Estructura de datos
SEM 2020 – I
ENTREGA DE ACTIVIDAD DE LA GUÍA N°4C MÉTODOS DE ORDENAMIENTO

Heapsort,Quicksort,Merge sort
1
XVI. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO QUICKSORT

Definición
Este método es una mejora sustancial del método de intercambio directo y recibe el nombre de Quick Sort, por la
velocidad con la que ordena los elementos del arreglo.
Quicksort 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.
Quicksort es actualmente el más eficiente y veloz de los métodos de ordenación interna.
Declaración
Pseudocódigo
INICIO
Llenar(A)
Algoritmo quicksort(A,inf,sup)
i<-inf
j<-sup
x<-A[(inf+sup)div 2]
Sintaxis C#
void tri_insertion(int* t, int gap, int debut)
{
int j,en_cours;
for (int i = gap + debut; i < 20; i+=gap) {
en_cours = t[i];
for (j = i; j >= gap && t[j - gap] > en_cours; j-=gap) {
t[j] = t[j - gap];
}
t[j] = en_cours;
}
}
4
Estructura de datos
SEM 2020 – I
void tri_shell(int* t) {
int intervalles[5]={6,4,3,2,1};
for (int ngap=0;ngap<5;ngap++) {
for (int i=0;i<intervalles[ngap];i++)
tri_insertion(t,intervalles[ngap],i);
Recorrido
Pseudocódigo
mientras i=<j hacer

mientras A[i]< x hacer
i<-i+1
fin_mientras
mientras A[j]>x hacer
j<- j-1
fin_mientras
si i=<j
entonces
tam<-A[i]
A[i]<-A[j]
A[j]<-tam
i=i+1
j=j-
1
fin_si
fin_mientra
s si inf<j
llamar_a quicksort(A,inf,j)
fin_si
si i<sup
llamar_a
quicksort(A,i,sup) fin_si
5
Estructura de datos
SEM 2020 – I
FIN
6
Estructura de datos
SEM 2020 – I
Operaciones con arreglos (Metodo De Ordenamiento Shell)
.
Recorrido
1. Se elige un elemento v de la lista L de elementos al que se le llama pivote.

2. Se particiona la lista L en tres listas:
1. L1 - que contiene todos los elementos de L menos v que sean menores o iguales que v
2. L2 - que contiene a v
3. L3 - que contiene todos los elementos de L menos v que sean mayores o iguales que v
3. Se aplica la recursión sobre L1 y L3
4. Se unen todas las soluciones que darán forma final a la lista L finalmente ordenada. Como L1 y L3 están ya
ordenados, lo único que tenemos que hacer es concatenar L1, L2 y L3
Aunque este algoritmo parece sencillo, hay que implementar los pasos 1 y 3 de forma que se favorezca la
velocidad de ejecución del algoritmo
mientras i=<j hacer
mientras A[i]< x hacer
i<-i+1
fin_mientras
mientras A[j]>x hacer
j<- j-1
fin_mientras
si i=<j entonces
tam<-A[i]
A[i]<-A[j]
A[j]<-tam
i=i+1
j=j-1
fin_si
fin_mientras
si inf<j
llamar_a quicksort(A,inf,j)
fin_si
si i<sup
7
Estructura de datos
SEM 2020 – I
llamar_a quicksort(A,i,sup)
fin_si
FIN
XVII. DESARROLLO DE LA GUIA

XVIII.
Ejemplo 1
Como el recorrido de izquierda a derecha debería iniciarse en la misma posición donde se encuentra el
elemento x, el proceso se termina ya que el elemento x, se encuentra en la posición correcta.
A: 12, 08, 15, 16, 44, 27, 67, 35
using System;
using System.Linq;
using System.Text;
namespace quicksort
{
class Class
{
static void Main()
{
int n;
Console.WriteLine("Metodo de Quick Sort");
Console.Write("Cuantos longitud del vector: ");
n = Int32.Parse(Console.ReadLine());
llenar b = new llenar(n);
}
}
class llenar
{
int h;
int[] vector;
public llenar(int n)
{
h = n;
vector = new int[h];
for (int i = 0; i < h; i++)
{
Console.Write("ingrese valor {0}: ", i + 1);
vector[i] = Int32.Parse(Console.ReadLine());
}
quicksort(vector, 0, h - 1);
mostrar();
}
private void quicksort(int[] vector, int primero, int ultimo)
{
int i, j, central;
double pivote;
central = (primero + ultimo) / 2;
pivote = vector[central];
i = primero;
j = ultimo;
do
{
8
Estructura de datos
SEM 2020 – I
while (vector[i] < pivote) i++;

while (vector[j] > pivote) j--;
if (i <= j)
{
int temp;
temp = vector[i];
vector[i] = vector[j];
vector[j] = temp;
i++;
j--;
}
} while (i <= j);
if (primero < j)
{
quicksort(vector, primero, j);
}
if (i < ultimo)
{
quicksort(vector, i, ultimo);
}
}
private void mostrar()
{
for (int i = 0; i < h; i++)
{
Console.Write("{0} ", vector[i]);
}
Console.ReadLine();
}
}
}
XIX. IMPLEMENTACIÓN EN UN LENGUAJE
C#
XX. REFERENCIAS BIBLIOGRÁFICAS
o Cursos Online C Sharp, Método de Ordenamiento de QuickSort en C#
o Algorithmique/Programmation, Ordenamiento por QuickSort, Français
9
Estructura de datos
SEM 2020 – I
2
XXI. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO MERGE SORT

Definición
Una técnica muy poderosa para el diseño de algoritmos es "Dividir para conquistar". Los algoritmos de este tipo se
caracterizan por estar diseñados siguiendo estrictamente las siguientes fases:
Dividir: Se divide el problema en partes más pequeñas.
Conquistar: Se resuelven recursivamente los problemas más chicos.
Combinar: Los problemas mas chicos de combinan para resolver el grande.
Los algoritmos que utilizan este principio son en la mayoría de los casos netamente recursivos como es el caso de mergesort.
El algoritmo de Mergesort es un ejemplo clásico de algoritmo que utiliza el principio de dividir para conquistar. Si el vector
tiene más de dos elementos se lo divide en dos mitades, se invoca recursivamente al algoritmo y luego se hace una
intercalación de las dos mitades ordenadas.
Declaración
Pseudocódigo
MergeSort (T [ ] a, entero n)
si ( n>1) entonces
{
a1= a[0...n/2 -1] ; // Primera mitad
a2= a[n/2...n-1] ; // Segunda mitad
MergeSort(a1, n/2);
MergeSort(a2, n – n/2);
Merge(a1,a2,a, n);
}
Sintaxis Java
a este metodo no le faltara algunas llaves? Intente muchas veces y nada:'v
public static void merge(int A[],int izq, int m, int der){
int i, j, k;
int [] B = new int[A.length]; //array auxiliar
for (i=izq; i<=der; i++) //copia ambas mitades en el array auxiliar
B[i]=A[i];
i=izq; j=m+1; k=izq;

while (i<=m && j<=der) //copia el siguiente elemento más grande
if (B[i]<=B[j])
A[k++]=B[i++];
else
A[k++]=B[j++];
while (i<=m) //copia los elementos que quedan de la
A[k++]=B[i++]; //primera mitad (si los hay)
}
1
Estructura de datos
SEM 2020 – I
Recorrido
Pseudocódigo
Merge(T [ ] a1,T [ ] a2, T [ ] a, entero n)

{
entero i, j, k;
i = j = k =0;
mientras(i < n/2 && j < n - n/2)
{
si(a1[i] < a2[j]) entonces
{
b[k] = a1 [i];
i++; k++;
}
sino
{
b[k] = a2[j];
j++; k++;
}
}
mientras(i < n/2)
{
b[k] = a1 [i];
i++; k++;
}
mientras(j < n-n/2)
{
b[k] = a2 [j];
j++; k++;
}
}
.
Recorrido
El método que hemos usado para resolver este problema se llama División y Conquista, y se aplica en las
situaciones en las que vale el siguiente principio:
Para obtener una solución es posible partir el problema en varios subproblemas de tamaño menor,
resolver cada uno de esos subproblemas por separado aplicando la misma técnica (en nuestro caso
ordenar por mezcla cada una de las dos sublistas), y finalmente juntar estas soluciones parciales en una
solución completa del problema mayor (en nuestro caso la intercalación ordenada de las dos sublistas
ordenadas).
Como siempre sucede con las soluciones recursivas, debemos encontrar un caso base en el cual no se
aplica la llamada recursiva (en nuestro caso la base sería el paso 1: Si la lista es pequeña (vacía o de
tamaño 1) ya está ordenada y no hay nada que hacer). Además debemos asegurar que siempre se alcanza
el caso base, y en nuestro caso aseguramos eso porque las lista original se divide siempre en mitades
cuando su longitud es mayor que 1.
1
Estructura de datos
SEM 2020 – I
Merge(T [ ] a1,T [ ] a2, T [ ] a, entero n)

{
entero i, j, k;
i = j = k =0;
mientras(i < n/2 && j < n - n/2)
{
si(a1[i] < a2[j]) entonces
{
b[k] = a1 [i];
i++; k++;
}
sino
{
b[k] = a2[j];
j++; k++;
}
}
mientras(i < n/2)
{
b[k] = a1 [i];
i++; k++;
}
mientras(j < n-n/2)
{
b[k] = a2 [j];
j++; k++;
1
Estructura de datos
SEM 2020 – I
XXII. DESARROLLO DE LA GUIA

Ejemplo 1
En el código usamos la clase vector (#include <vector.h>) para crear los vectores,
obviamente funciona igual de bien si se utilizan los arrays tipo C: TIPO V[]
4.4. DISEÑO
template <class T, class U>

void fusiona(vector<T>& v, U ini, U med, U fin) {
vector<T> aux(fin - ini + 1);
int i = ini; // Índice de la parte izquierda
int j = med + 1; // Índice de la parte derecha
int k = 0; // Índice del vector aux
/* Mientras ninguno de los indices llegue a su fin vamos realizando

comparaciones. El elemento más pequeño se copia al vector aux */
while (i <= med && j <= fin) {
if (v[i] < v[j]) {
aux[k] = v[i];
i++;
}
else {
aux[k] = v[j];
j++;
}
k++;
}
/* Uno de los dos sub-vectores ya ha sido copiado del todo, simplemente

debemos copiar todo el sub-vector que nos falte */
while (i <= med) {
aux[k] = v[i];
i++;
k++;
}
while (j <= fin) {

aux[k] = v[j];
j++;
k++;
}
/* Copiamos los elementos ordenados de aux al vector original v */

for (int n = 0; n < aux.size(); ++n) v[ini + n] = aux[n];
}
1
Estructura de datos
SEM 2020 – I
template <class T, class U>

void merge_sort(vector<T>& v, U ini, U fin) {
/* Si ini = fin el sub-vector es de un solo elemento y, por lo tanto
ya está ordenado por definición */
if (ini < fin) {
/*Considerar que el valor de med siempre es redondeado hacia abajo.*/
int med = (ini + fin)/2;
merge_sort(v, ini, med);
merge_sort(v, med + 1, fin);
fusiona(v, ini, med, fin);
}
}
XXIII. IMPLEMENTACIÓN EN UN LENGUAJE
C++
XXIV. REFERENCIAS BIBLIOGRÁFICAS
o Cursos Online C Sharp, Método de Ordenamiento Merge C++
o Algorithmique/Programmation, Ordenamiento por Merge , Français
2
Estructura de datos
SEM 2020 – I
XXV. FUNDAMENTOS TEÓRICOS
METODO DE ORDENAMIENTO HeapSort

Definición
Es una estructura de datos del tipo árbol binario. Este árbol binario tiene que ser completo, en otras
palabras, cada nivel debe de estar lleno con excepción del ultimo nivel, en el último nivel, los hijos
debe recargarse hacia un mismo lado, generalmente hacia el lado izquierdo, así como se muestra
en la imagen de la derecha.
Declaración
Pseudocódigo
HEAPSORT( T[ ] A, entero n) {
BUILD_HEAP(A, n); (1)
Sintaxis Java
void shiftRight(int* arr, int low, int high)

{
int root = low;
while ((root*2)+1 <= high)
{
int leftChild = (root * 2) + 1;
int rightChild = leftChild + 1;
int swapIdx = root;
/*Check if root is less than left child*/
if (arr[swapIdx] < arr[leftChild])
{
swapIdx = leftChild;
}
/*If right child exists check if it is less than current root*/
if ((rightChild <= high) && (arr[swapIdx] < arr[rightChild]))
{
swapIdx = rightChild;
}
/*Make the biggest element of root, left and right child the root*/
if (swapIdx != root)
{
int tmp = arr[root];
arr[root] = arr[swapIdx];
arr[swapIdx] = tmp;
/*Keep shifting right and ensure that swapIdx satisfies
heap property aka left and right child of it is smaller than
itself*/
root = swapIdx;
}
else
{
break;
}
}
return;
3
Estructura de datos
SEM 2020 – I
}
void heapify(int* arr, int low, int high)
{
/*Start with middle element. Middle element is chosen in
such a way that the last element of array is either its
left child or right child*/
int midIdx = (high - low -1)/2;
while (midIdx >= 0)
{
shiftRight(arr, midIdx, high);
--midIdx;
}
return;
}
void heapSort(int* arr, int size)
{
assert(arr);
assert(size > 0);
/*This will put max element in the index 0*/
heapify(arr, 0, size-1);
int high = size - 1;
while (high > 0)
{
/*Swap max element with high index in the array*/
int tmp = arr[high];
arr[high] = arr[0];
arr[0] = tmp;
--high;
/*Ensure heap property on remaining elements*/
shiftRight(arr, 0, high);
}
return;
}
4
Estructura de datos
SEM 2020 – I
Recorrido
Pseudocódigo
mientras(n > 1)
{ Intercambiar(A, 0, n- 1); (2)
n--; (3)
HEAPIFY(A, 0, n); (4)
Operaciones con arreglos (Metodo De Ordenamiento HeapSort)
Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un montículo (heap),
y luego extraer el nodo que queda como nodo raíz del montículo (cima) en sucesivas iteraciones
obteniendo el conjunto ordenado. Basa su funcionamiento en una propiedad de los montículos, por la
cual, la cima contiene siempre el menor elemento (o el mayor, según se haya definido el montículo) de
todos los almacenados en él. El algoritmo, después de cada extracción, recoloca en el nodo raíz o cima,
la última hoja por la derecha del último nivel. Lo cual destruye la propiedad heap del árbol. Pero, a
continuación realiza un proceso de "descenso" del número insertado de forma que se elige a cada
movimiento el mayor de sus dos hijos, con el que se intercambia..
Recorrido
El algoritmo, después de cada extracción, recoloca en el nodo raíz o cima, la última hoja por la derecha
del último nivel. Lo cual destruye la propiedad heap del árbol. Pero, a continuación realiza un proceso
de "descenso" del número insertado de forma que se elige a cada movimiento el mayor de sus dos hijos,
con el que se intercambia..
mientras(n > 1)
{ Intercambiar(A, 0, n- 1); (2)
n--; (3)
HEAPIFY(A, 0, n); (4)
5
Estructura de datos
SEM 2020 – I
XXVI. DESARROLLO DE LA GUIA

XXVII.
Ejemplo 1
Claro para poder aplicar este método es algún software, uno requiere de un código, un cogido
que es un tanto largo, enseguida se le mostrara un ejemplo de código en C++ :
void shiftRight(int* arr, int low, int high)

{
int root = low;
while ((root*2)+1 <= high)
{
int leftChild = (root * 2) + 1;
int rightChild = leftChild + 1;
int swapIdx = root;
/*Check if root is less than left child*/
if (arr[swapIdx] < arr[leftChild])
{
swapIdx = leftChild;
}
/*If right child exists check if it is less than current root*/
if ((rightChild <= high) && (arr[swapIdx] < arr[rightChild]))
{
swapIdx = rightChild;
}
/*Make the biggest element of root, left and right child the root*/
if (swapIdx != root)
{
int tmp = arr[root];
arr[root] = arr[swapIdx];
arr[swapIdx] = tmp;
/*Keep shifting right and ensure that swapIdx satisfies
heap property aka left and right child of it is smaller than
itself*/
root = swapIdx;
}
else
{
break;
}
}
return;
}
void heapify(int* arr, int low, int high)
{
/*Start with middle element. Middle element is chosen in
such a way that the last element of array is either its
left child or right child*/
int midIdx = (high - low -1)/2;
while (midIdx >= 0)
{
shiftRight(arr, midIdx, high);
--midIdx;
}
return;
}
void heapSort(int* arr, int size)
{
6
Estructura de datos
SEM 2020 – I
assert(arr);
assert(size > 0);
/*This will put max element in the index 0*/
heapify(arr, 0, size-1);
int high = size - 1;
while (high > 0)
{
/*Swap max element with high index in the array*/
int tmp = arr[high];
arr[high] = arr[0];
arr[0] = tmp;
--high;
/*Ensure heap property on remaining elements*/
shiftRight(arr, 0, high);
}
return;
}
XXVIII. IMPLEMENTACIÓN EN UN LENGUAJE
C++
XXIX. REFERENCIAS BIBLIOGRÁFICAS
 Solar, M. (2008). Heapsort. Obtenido de Estructuras de Datos: http://estructuras-de-

datos.wikispaces.com/Heapsort

 Solórzano, J. (2012). HeapSort. Obtenido de http://www.slideshare.net/jhosep94/heap-sort-15397805

Trabajo Metodos de Ordenamiento

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo Metodos de Ordenamiento

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD ANDINA DEL CUSCO

FACULTAD DE INGENIERÍA Y ARQUITECTURA

Datos del estudiante

Nombre y apellidos: Reny Rodrigo Luque Rios, Ochoa Moreano Jhonatan

FECHA : 03 DE marzo de 2020

II. FUNDAMENTOS TEÓRICOS

METODO DE ORDENAMIENTO INSERCION

Procedimiento Insertion_Sort ( Vector A[1:N])

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

for (j = i; j > 0 && t[j - 1] > actual; j--) {

t[j] = t[j - 1];

Para I Variando De 2 Hasta N Hacer

Insertar A[I] En Su Lugar En A[1:I-1];

Operaciones con arreglos (Metodo De Ordenamiento Insercion)

Consiste en ir insertando un elemento de la lista ó un arreglo en la parte ordenada de la misma,

Para I Variando De 2 Hasta N Hacer

Insertar A[I] En Su Lugar En A[1:I-1];

III. DESARROLLO DE LA GUIA

private int[] vector;

public void Cargar()

Console.WriteLine("Metodo de insercion directa");

Console.Write("Cuantos longitud del vector:");

vector = new int[cant];

for (int f = 0; f < vector.Length; f++)

Console.Write("Ingrese elemento "+(f+1)+": ");

public void InsercionDirecta()

for (int i = 0; i < vector.Length; i++)

while (j >= 0 && vector[j] > auxili)

public void Imprimir()

Console.WriteLine("Vector ordenados en forma ascendente");

for (int f = 0; f < vector.Length; f++)

static void Main(string[] args)

PruebaVector pv = new PruebaVector();

IV. IMPLEMENTACIÓN EN UN LENGUAJE

o Cursos Online C Sharp, Método de Ordenamiento de Inserción Directa en C#

o Algorithmique/Programmation, Ordenamiento por inserción, Français

VI. FUNDAMENTOS TEÓRICOS

METODO DE ORDENAMIENTO SELECCION

para i=1 hasta n-1;

Java void selecccion(int[] a) {

for (int i = 0; i < a.length - 1; i++)

for (int j = i + 1; j < a.length; j++)

para j=i+1 hasta n

si lista[j] < lista[minimo] entonces

Operaciones con arreglos (Metodo De Ordenamiento Insercion)

para j=i+1 hasta n

si lista[j] < lista[minimo] entonces

VII. DESARROLLO DE LA GUIA

for llenarRanura in range(len(unaLista)-1,0,-1):

for ubicacion in range(1,llenarRanura+1):

IX. IMPLEMENTACIÓN EN UN LENGUAJE

o Cursos Online C Sharp, Método de Ordenamiento de Seleccion en Java

o Algorithmique/Programmation, Ordenamiento por Seleccion, Français

XI. FUNDAMENTOS TEÓRICOS

METODO DE ORDENAMIENTO SHELL

ROCEDURE tri_Insertion ( Tableau a[1:n],gap,debut)

POUR i VARIANT DE debut A n AVEC UN PAS gap FAIRE

INSERER a[i] à sa place dans a[1:i-1];

void tri_insertion(int* t, int gap, int debut)

for (int i = gap + debut; i < 20; i+=gap) {

for (j = i; j >= gap && t[j - gap] > en_cours; j-=gap) {

t[j] = t[j - gap];

for (int ngap=0;ngap<5;ngap++) {