jamás pongas bordes decorativos en un texto técnico

Método de Ordenamiento Heapsort

Monticulos (Heaps)
Un montículo es un árbol binario tal que
Todos las hojas (subárboles son vacíos) se sitúan en los dos últimos niveles del
árbol.
En el antepenúltimo nivel existe un nodo con un sólo hijo, que será su hijo
izquierdo, y todos los nodos a su derecha en el mismo nivel son nodos sin hijos.
El elemento almacenado en un nodo cualquiera es mayor (menor) o igual que los
elementos almacenados en sus hijos izquierdo y derecho.
dales otro estilo a las variables, algo como cursiva
Heapsort (Williams, 1964) ordena un vector de n elementos construyendo un heap con
los n elementos y extrayéndolos, uno a uno del heap a continuación. El propio vector que
almacena a los n elementos se emplea para construir el heap, de modo que heapsort
actúa en el lugar y sólo requiere un espacio auxiliar de memoria constante. El coste de
este algoritmo es (n log n) si todos los elementos son diferentes.
El Heapsort es el más eficiente de los métodos de ordenación que trabajan con árboles.
La idea central de este algoritmo consiste en lo siguiente:
Construir un montículo.
Eliminar la raíz del montículo en forma repetida.

Forma
A Clasificada
A B
D C
E B C D

Elementos

hay que identificar el origen de cada figura

 La estructura de datos Moticulo es un arreglo de objetos que puede ser vito como un
arbol binario con raiz, cuyos nodos pertenecen a un conjunto totalmente ordenado, y tal
que cumple las siguentes dos propiedades:
a)Propiedad de orden: La raiz de cada subarbol es mayor o igual que cualquiera de sus
nodos restantes.
b) Propiedad de forma: La longitud de toda la rama es h o h-1, donde “h” es la altura
del arbol.

Gráficamente:
Representación de un Montículo.

arreglo
Utilizamos array para representar un árbol binario.

1 “Raíz”

16

3 “Árbol
2 binario”
10
14 no uses comillas como decoración;
son puntuación y tienen un
significado específico
4 6 7

8 5 3
7 9

9
8 10
“Arreglo”
2 4 1

1 2 3 4 5 6 7 8 9 10

16 14 10 8 7 9 3 2 4 1
Caracteristicas

El significado de heap en ciencia computacional es el de una cola de prioridad

(priority queque).

Un heap es un arreglo de”n” posiciones ocupado por los elementos de la cola.

Se utiliza un arreglo que inicia en la posicion 1 y no en cero.
Se mapea un arbol binario de tal manera en el arreglo en la posicion i es el padre
de los nodos en las posicione (2*i) y (2*+1). no uses * para multiplicación, usa símbolos matemáticos
El valor en un nodo es mayor o igual a los valores de sus hijos.
Por consiguiente, el nodo padre tiene el mayor valor de todo su subarbol.

Ventajas
La principal ventaja es que este método funciona más efectivamente con datos
desordenados.
Su desempeño es en promedio tan bueno como el Quicksort y se comporta mejor
que este último en los peores casos.
No utiliza memoria adicional.
evita las listas; es mejor redactar párrafos

Desventajas
No es estable, ya que se comporta de manera ineficaz con datos del mismo valor.
Método más complejo.

Aplicaciones
Una de las grandes aplicaciones de Heapsort es construir colas de prioridad con la idea
que busque los procesos que llevan la mayor carga de prioridad dado una gran cantidad
de procesos por hacer.
Otras aplicaciones es la programación de intervalos, tenemos una lista de tareas con un
tiempo limitado. En esencia una aplicación o algoritmo que trate sobre ordenar una lista
de elementos dependerá eficientemente en un algoritmo de ordenamiento, y el método
heapsort puede realizar tal función.
 Ejemplo Heapsort Codigo en C++
es primordial identificar de dónde es el código

/* C++ Programa para poner en práctica Heapsort */ MAX_HEAPIFY(a, k, n);

#include <iostream> }

using namespace std; }

void MAX_HEAPIFY(int a[], int i, int n) void HEAPSORT(int a[], int n)

{ {

int l,r,largest,loc; BUILD_MAX_HEAP(a,n);

l=2*i; int i, temp;

r=(2*i+1); for (i = n; i >= 2; i--)

if((l<=n)&&a[l]>a[i]) {

largest=l; temp = a[i];

else a[i] = a[1];

largest=i; a[1] = temp;

if((r<=n)&&(a[r]>a[largest])) MAX_HEAPIFY(a, 1, i - 1);

largest=r; }

if(largest!=i) }

{ int main()

loc=a[i]; {

a[i]=a[largest]; int n;
a[largest]=loc; cout<<"Introducir el tamaño de la serie"<<endl;

MAX_HEAPIFY(a, largest,n); cin>>n;

} int a[n];

} cout<<"Introducir los elementos de la serie"<<endl;

void BUILD_MAX_HEAP(int a[], int n) for (int i = 1; i <= n; i++)

{ {

for(int k = n/2; k >= 1; k--) cin>>a[i];

{ }
HEAPSORT(a, n);
cout<<":::::::FORMA CLASIFICADA::::::"<<endl;
for (int i = 1; i <= n; i++)
{
cout<<a[i]<<endl;
}
}
 Colas de prioridad
Se basan en el orden de salida de sus elemntos: en el orden de llegada y orden de
prioridad; asi un elemento que ingresa a la cola se posicionara al final del segmento de
elementos de su misma prioridad es decir, el elemento de mayor prioridad es procesado
primero, dos elementos con la misma prioridad son procesados según el orden en que
fueron introducidos en la cola.

Problema Planteado
Un problema que se puede presentar en la vida cotidiana y en el cual podemos
implementar el metodo de ordenamiento heapsort puede ser aplicado en un hospital ya
que muchas veces atienden al paciente que ha llegado primero o que solicito una cita
pero en el cual es necesario atender el paciente que este mas grave primero.
Es necesario para solucionarlo seria: analizar y comprender las operaciones críticas de
una cola de prioridad implementada mediante un Heap, así como su complejidad
temporal.
Triage (en francés) es un método por el cual se seleccionan y se clasifican a los
pacientes en las salas de urgencia. Se les debe dar prioridad a los pacientes que tienen
mayor urgencia de ser atendidos (debido a la gravedad del caso). Cada país suele
tener sus propias categorías numéricas o por colores para expresar la urgencia de
cada paciente. En este caso utilice el triage del Instituto Mexicano del Seguro Social
(IMSS) lo cual puede dar solución eficaz al momento de clasificar a los pacientes que
más requieran ser atendidos por un hospital cercano.
Esta es la clasificación del Seguros Social de Pacientes que acuden a urgencias con
escala confiable de 5 niveles. cifras sencillas aisladas van en letra: 5 -> cinco
Categoria
TRIAGE o Color Signos o sintomas Diagnostico Tiempo maximo de
NIVEL centinela espera
1 Rojo Insuficiencia Neumotorax Tratamiento inmediato
Resusitacion respiratoria severa traumatico
2 Naranja Exposicion quimica en Quemadura en Dentro de los primeros
Emergencia ojos ojos por acido o 10 minutos
alcalino
3 Amarillo Traumatismo de tobillo Fractura de tobillo Dentro de los primeros
Urgencia 30 minutos
4 Verde Herida en cabeza con Traumatismo Dentro de los primeros
Semi-urgencia alerta y sin vomito craneoencefalico 60 minutos a su UMF

5 Azul Diarrea con Gastroenteritis Dentro de los

No urgencia hidratacion normal promeros 120 minuos
en su UMF
Para este caos el hospital cuenta con un sistema que le permite registrar los pacientes.
Uno vez uno de estos llega al registro de urgencias, un empleado lo registra en el
sistema y le asigna el nivel de triage que considere necesario. Luego, al momento de
que haya un médico disponible, a enfermera escoge al paciente que debe ser atendido
con mayor prioridad gracias al sistema.
El sistema del paciente funciona bajo el siguiente modelo de datos de la central de
pacientes:

Central Pacientes Paciente

Primero

Siguiente

Cola de prioridad Codigo en C++ en pacientes que mas necesitan ser

atendidos.
/* * C++ “Cola de prioridad” Mostrar Cola
*/ ------------------------------------------------------------------------*/
#include <iostream> void muestraCola( struct cola q )
#include <stdlib.h> {
using namespace std; struct nodo *aux;
/* Estructura de los nodos de la cola aux = q.delante;
------------------------------------------------------------------------*/ cout << " Caracter Prioridad " << endl;
struct nodo cout << " ------------------- " << endl;
{ while( aux != NULL )
char dato; {
int priori; // prioridad del nodo cout<<" "<< aux->dato << " | " << aux-
>priori << endl;
struct nodo *sgte;
aux = aux->sgte;
};
}
/* Estructura de la cola
}
------------------------------------------------------------------------*/
/* Ordenar por prioridad( criterio de Ordenamiento)
struct cola
------------------------------------------------------------------------*/
{
void ordenarPrioridad( struct cola &q )
nodo *delante;
{
nodo *atras ;
struct nodo *aux1, *aux2;
};
int p_aux;
/* Crear Nodo
char c_aux;
------------------------------------------------------------------------*/
aux1 = q.delante;
struct nodo *crearNodo( char x, int pr)
while( aux1->sgte != NULL)
{
{
struct nodo *nuevoNodo = new(struct nodo);
aux2 = aux1->sgte;
nuevoNodo->dato = x;
while( aux2 != NULL)
nuevoNodo->priori = pr;
{
return nuevoNodo;
if( aux1->priori > aux2->priori )
};
{
/* Encolar cacarter con prioridad
p_aux = aux1->priori;
------------------------------------------------------------------------*/
c_aux = aux1->dato;
void encolar( struct cola &q, char valor, int priori )
aux1->priori = aux2->priori;
{
aux1->dato = aux2->dato;
struct nodo *aux = crearNodo(valor, priori);
aux2->priori = p_aux;
aux2->dato = c_aux;
aux->sgte = NULL;
}
if( q.delante == NULL)
aux2 = aux2->sgte;
q.delante = aux; // encola el primero elemento
}
else
aux1 = aux1->sgte;
(q.atras)->sgte = aux;
}
q.atras = aux; // puntero que siempre apunta al ultimo elemento
}
}
/* Insertar cacacteres en una cola {
------------------------------------------------------------------------*/ case 1:
void insertar( struct cola &q, char c, int pr ) cout<< "\n Ingrese caracter: ";
{ cin>> c;
/* Encolando caracteres */ cout<< "\n Ingrese prioridad: ";
encolar( q, c, pr ); cin>> pr;
/* Ordenando por prioridad */ insertar( q, c, pr );
ordenarPrioridad( q ); cout<<"\n\n\t\tCaracter '" << c << "'
} encolado...\n\n";

/* Menu de opciones break;

------------------------------------------------------------------------*/ case 2:

void menu() cout << "\n\n MOSTRANDO COLA

DE PRIORIDAD\n\n";
{
if(q.delante!=NULL)
cout<<"\n\t COLAS CON PRIORIDAD EN C++
\n\n"; muestraCola( q );

cout<<" 1. ENCOLAR "<<endl; else

cout<<" 2. MOSTRAR "<<endl; cout<<"\n\n\tCola vacia...!"<<endl;

cout<<" 3. SALIR "<<endl; break;

cout<<"\n INGRESE OPCION: "; default:

} cout<<"\n\tOpcion
incorecta..!"<<endl;
/* Funcion Principal
system("pause");
------------------------------------------------------------------------*/
exit(0);
int main()
}
{
cout<<endl<<endl;
struct cola q;
system("pause"); system("cls");
q.delante = NULL;
}while(op!=3);
q.atras = NULL;
return 0;
char c ; // caracter a encolar
}
int pr; // prioridad del caracter
int op; // opcion del menu
int x ; // numero que devuelve la funcon pop
do
{
menu(); cin>> op;
switch(op)
Conclusión

Este metodo de ordenamiento de heapsort que se investigo en este proyecto tiene una
ventaja con respecto a otros ya que su desempeño es en promedio tan bueno como el
de Quicksort otro método de ordenamiento muy eficiente, y se comporta mejor que este
ultimo en los peores casos y que tambien no es recursivo. Es conveniente cuando se
trata de ordenar arreglos estáticos a diferencia de otros métodos.
Aunque el Heapsort tiene un mejor desempeño general que cualquier otro metodo
presentado de clasificacion interna, en el sentido a el manejo de los recursos de memoria
cuando se ejecua, es un poco complejo de programar.
Dado también que O(n log n) como límite para el tiempo de funcionamiento en heapsort
y un límite superior constante en su almacenamiento auxiliar, los sistemas preocupados
con la seguridad mayormente usan heapsort.
Planteando el problema del hospital que muchos tenemos problemas de ser atendidos
aunque estemos gravemente heridos, ya que en algunos casos atienden al paciente que
valla llegando primero pero gracias al método de ordenamiento Heapsort el cual abarca
las cola de prioridad puede solucionar satisfactoriamente el que sean atendidos no
vayan
importa conforme vallan llegando sino conforme a la gravedad del paciente ya que
requiere la atención necesaria del doctor.
Bibliografias

URL: http://www.lcc.uma.es/~av/Libro/CAP2.pdf
URL:http://www.hib-wien.at/leute/wurban/informatik/sortieren/sort6_heap.pdf
Wolfgang Urba. (8, 2002). Heapsort. De HIB Viena.
URL: http://www.cimat.mx/~alram/comp_algo/clase17.pdf el formato de la
bibliografía no es
Ramirez Manzanares A. (4, 2017). Heaps y Heapsort. adecuada; faltan
muchos datos