

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Prepara tus exámenes con los documentos que comparten otros estudiantes como tú en Docsity
Encuentra los documentos específicos para los exámenes de tu universidad
Estudia con lecciones y exámenes resueltos basados en los programas académicos de las mejores universidades
Responde a preguntas de exámenes reales y pon a prueba tu preparación
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Comunidad
Pide ayuda a la comunidad y resuelve tus dudas de estudio
Ebooks gratuitos
Descarga nuestras guías gratuitas sobre técnicas de estudio, métodos para controlar la ansiedad y consejos para la tesis preparadas por los tutores de Docsity
En este documento se presentan dos algoritmos de ordenamiento: counting sort y heap sort. Counting sort requiere la suposición de que los elementos a ordenar tienen una estructura conocida, como por ejemplo enteros en [1, k]. Heap sort utiliza un arreglo que representa un árbol binario completo que cumple la propiedad del heap. La complejidad temporal de counting sort es o(n + k), mientras que la de heap sort es o(n log n).
Tipo: Apuntes
Subido el 01/07/2020
1 / 2
Esta página no es visible en la vista previa
¡No te pierdas las partes importantes!


Ordenar Arreglar un conjunto de elementos de una cierta manera. Ordenamiento de una secuencia El ordenamiento de una secuencia {a 1 , a 2 , ..., an} obtenidas del conjunto con orden lineal, es una permutación {ai1, ai2, ..., ain} tal que ai<=ai+1, ∀i.
(Counting_Sort) Suposición: los elementos por ordenar tienen una estructura conocida. Por ejemplo, son enteros en [1, k] Counting_Sort(A, B, k) for i = 1 to k do C[i]= for j = 1 to length(A) do C[ A[ j ] ] = C[ A[ j ] ] + 1 for i = 2 to k do C[ i ] = C[ i ] +C[ i -‐1 ] for j = length(A) downto 1 do B[ C[ A[ j ] ] ] = A[ j ] C[ A[ j ] ] = C[ A[ j ] ] – 1 Complejidad temporal:
Heap
= On k On Ok n Tconteo n
Algoritmo Heapify (A, i) l = left( i ) r = right( i ) if l<=heapsize(A) y A[ l ]>A[ i ] largest = l else largest = i if r<=heapsize(A) y A[ r ]> A[ largest ] largest = r if largest != i then exchange(A[ i ], A[largest]) heapify(A, largest) La complejidad de la acción heapify es: donde h es la altura del subárbol afectado Algoritmo de construcción de un Heap Build_heap(A) heapsize(A) = length(A) for j = !"#$%!(!) ! downto 1 do heapify (A, j) Algoritmo de ordenamiento Heap_sort(A) Build_heap(A) for j = length (A) downto 2 exchange (A[ 1 ], A[ j]) heapsize(A) = heapsize(A) – 1 heapify(A, 1) Análisis de la complejidad de Build Heap Se puede calcular el límite superior de una manera sencilla como sigue: Cada llamada de heapify tiene un costo O(lg n) y son O(n) llamadas, por lo que T(n) = O(n lg n). Este límite superior aunque es correcto, no es asintóticamente correcto. Se puede calcular un límite más correcto si tomamos en cuenta que el tiempo de heapify de cada nodo varía según su altura dentro del árbol y la altura de la mayoría de los nodos es pequeña. Este análisis se basa en las propiedades de que el n-‐elemento de un heap tiene altura lg! y a lo más hay ! !!!!^ nodos de cualquier altura h. El tiempo de heapify para un nodo de altura h es O(h), por lo que Build Heap puede ser limitado como sigue: ! 2 !!! !"! !!!
!"! !!! y como! !!!!!!^ = ! !!!!^
si x = ½ ℎ
!! !!!
Entonces: !! ! !! !"! !!! =^!^!^ ! !! ! !!! =^!^2!^ =^ !(!) TBuildHeap (n) = O(n) La complejidad del algoritmo Heap Sort es:
Quicksort(A, p, r) if p<r then q = Partition (A, p, r) Quicksort(A, p, q) Quicksort(A, q+1, r) Partition(A, p, r) x = A[ p ] i = p-‐1, j= r+ while true repeat j = j-‐1 until A[ j ]<=x repeat i = i+1 until A[ i ]>=x if i<j then exchange(A[ i ], A[ j ]) else return j La complejidad de Quick Sort es:
heap _ sort 2
T n O n n T n O n 2 2 2 log log = = =