Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad


Algoritmos de Ordenamiento: Counting Sort y Heap Sort, Apuntes de Algoritmos Avanzados

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

2019/2020

Subido el 01/07/2020

usuario desconocido
usuario desconocido 🇲🇽

1 / 2

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
2.#Algoritmos#de#ordenamiento#
#
2.1#Introducción#
Ordenar!!
Arreglar!un!conjunto!de!elementos!de!una!
cierta!manera.!
Ordenamiento#de#una#secuencia#
El!ordenamiento!de!una!secuencia!{a1,!a2,!
...,!an}!obtenidas!del!conjunto!con!orden!lineal,!es!
una!permutación!{ai1,!ai2,!...,!ain}!!tal!que!ai<=ai+1,!
i.!
2.2#Ordenamiento#por#conteo#
(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]=0!
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!L1!]!
for!j!=!length(A)!downto!1!do!
! B[!C[!A[!j!]!]!]!=!!A[!j!]!!
! C[!A[!j!]!]!=!C[!A[!j!]!]!–!1!
!
Complejidad!temporal:!
!
!
!
!
!
!
2.3#Heap#Sort#
#
Heap#
Es!un!arreglo!A!que!contiene!valores.!
Representa!un!árbol!binario!completo!que!
cumple!la!propiedad!del!heap:!
A[!padre(i)!]!>=!A[!i!]!
Está!construido!de!la!siguiente!forma:!
A[!1!]!contiene!la!raíz!
A[!2i!]!y!A[!2i!+1!]!!contienen!
respectivamente!los!hijos!izquierdo!y!
derecho!de!A[!i!]!
Todo!camino!de!una!hoja!a!la!raíz!es!una!
secuencia!ordenada.!!
!
!
!
Heapify#
Es!la!operación!básica!que!permite!mantener!
el!orden!en!un!heap.!
Consiste!en!la!comprobación!recursiva!de!la!
condición!básica!del!heap!a!partir!del!nodo!i.!
!
Dra.!Blanca!Esthela!Solís!Recéndez!
( ) ( )
( ) ( )
⎩
⎨
⎧
=
+
=nOknO
nkO
nTconteo
pf2

Vista previa parcial del texto

¡Descarga Algoritmos de Ordenamiento: Counting Sort y Heap Sort y más Apuntes en PDF de Algoritmos Avanzados solo en Docsity!

2. Algoritmos de ordenamiento

2.1 Introducción

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.

2.2 Ordenamiento por conteo

(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:

2.3 Heap Sort

Heap

  • Es un arreglo A que contiene valores.
  • Representa un árbol binario completo que cumple la propiedad del heap: A[ padre(i) ] >= A[ i ]
  • Está construido de la siguiente forma: A[ 1 ] contiene la raíz A[ 2i ] y A[ 2i +1 ] contienen respectivamente los hijos izquierdo y derecho de A[ i ]
  • Todo camino de una hoja a la raíz es una secuencia ordenada. Heapify
  • Es la operación básica que permite mantener el orden en un heap.
  • Consiste en la comprobación recursiva de la condición básica del heap a partir del nodo i. Dra. Blanca Esthela Solís Recéndez ( ) ( ) ⎩^ (^ )^ (^ ) ⎨ ⎧ =

= 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 = ½ ℎ

!! !!!

! =^2

Entonces: !! ! !! !"! !!! =^!^!^ ! !! ! !!! =^!^2!^ =^ !(!) TBuildHeap (n) = O(n) La complejidad del algoritmo Heap Sort es:

Algoritmo de ordenamiento Quicksort

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:

  • Peor de los casos:
  • Mejor de los casos:
  • Caso promedio: Dra. Blanca Esthela Solís Recéndez

( ) ( ) O ( n ) O ( h )

n

Theapify n Theapify ⎟+Θ = =

≤ 1 log 2

T ( n ) O ( n n )

heap _ sort 2

= log

T ( n ) O ( n n )

T n O n n T n O n 2 2 2 log log = = =