Búsqueda y Ordenación en Python, Apuntes de Física

¡Descarga Búsqueda y Ordenación en Python y más Apuntes en PDF de Física solo en Docsity!

10 Marzo 201 4

Búsqueda y ordenación

Fundamentos de Programación

Búsqueda

Formulación del problema

‣ En este tema se estudian soluciones a problemas de búsqueda y

ordenación sobre estructuras lineales

‣ Se supondrá que el acceso a los elementos es aleatorio y de coste

fijo (independiente del tamaño del vector o matriz)

‣ Además de mostrar con ejemplos que puede haber distintas

soluciones a un problema, se tratará de evaluar cualitativamente el coste temporal de cada solución y analizar la idoneidad de una u otra en función del tamaño del problema

‣ Problema de la búsqueda:^ dado un vector v (de longitud n) y

un valor x, deberá devolverse una posición (entre 0 y n-1) donde aparezca x; en caso de no encontrarla, se devolverá None

Búsqueda secuencial

‣ Si el vector está ordenado, la

búsqueda secuencial puede acabar en cuanto detecta que el valor buscado es menor que el actual: def buscar2 (v,x): n=len(v) for i in range(n): if v[i]==x: return i elif v[i]>x: return None return None

‣ Curiosamente, dependiendo

del valor de x, el coste temporal de buscar2() puede ser menor (x pequeños) o mayor (x grandes) que el de buscar()

‣ Sin embargo, el orden de

magnitud del coste es idéntico: en el mejor caso se realiza un único paso y en el peor, n pasos

Búsqueda dicotómica

‣ Si el vector está ordenado, la

solución más eficiente es la búsqueda dicotómica: def bdicr(v,i,j,x): if i>j: return None m=(i+j)// if x<v[m]: return bdicr(v,i,m-1,x) if x>v[m]: return bdicr(v,m+1,j,x) return m

‣ La función se define

recursivamente, reduciendo el intervalo de búsqueda a la mitad con cada llamada

‣ La primera llamada es:

bdicr(v, 0, len(v)-1, x)

‣ Mejor caso : 1 paso/llamada

(x está justo en la mitad del vector)

‣ Peor caso :^ log 2 (n)^ +

pasos/llamadas (x no se encuentra en el vector)

Ordenación

‣ El objetivo de la ordenación es únicamente poder aplicar métodos

eficientes de búsqueda

‣ Problema de la ordenación : sea v un vector de valores entre los

que se establece una relación de orden; el objetivo es reorganizar los valores en el propio vector, de modo que v[i]<=v[j] para cualquier i<j

‣ Si el vector v se ha representado mediante una lista, el método

sort realiza precisamente esa tarea: v.sort()

‣ Existen métodos sencillos de ordenación que en el peor caso

implican un número de pasos proporcional a n 2 , y métodos más eficientes ( quicksort , mergesort , etc.) que en un caso promedio implican del orden de n*log 2 (n) pasos

Ordenación por inserción

‣ Ordenación por inserción

def sort_ins(v): n=len(v) for i in range(1,n): x=v[i] j=i- while j>=0 and x<v[j]: v[j+1]=v[j] j=j- v[j+1]=x

‣ Ejemplo :

i=0 3 1 7 -1 0 5 i=1 1 3 7 -1 0 5 i=2 1 3 7 -1 0 5 i=3 -1 1 3 7 0 5 i=4 -1 0 1 3 7 5 i=5 -1 0 1 3 5 7

‣ Mejor caso : n-1 pasos (vector

ordenado)

‣ Peor caso : del orden de n

2 pasos (vector en orden inverso)...

Ordenación por selección

‣ Ordenación por selección

def sort_sel(v): n=len(v) for i in range(0,n-1): minimo=v[i] argmin=i for j in range(i+1,n): if v[j]<minimo: minimo=v[j] argmin=j v[argmin]=v[i] v[i]=minimo

‣ Ejemplo :

i=0 -1 1 7 3 0 5 i=1 -1 0 7 3 1 5 i=2 -1 0 1 3 7 5 i=3 -1 0 1 3 7 5 i=4 -1 0 1 3 5 7

‣ Coste temporal : del orden de n

2 pasos (en todos los casos)...

Ordenación por selección

Coste temporal

del orden de"

n

2

pasos

Ordenación por intercambio

Coste temporal

del orden de"

n

2

pasos

Ordenación por partición:

quicksort

Ordenación por partición:

quicksort

‣ Ejemplo^ (ver^ demo^ en YouTube):

(0,5) pivote = 0 3 1 7 -1 0 5 0 1 7 -1 3 5 0 -1 7 1 3 5 j=1, i= (0,1) pivote = 0 0 -1 7 1 3 5 -1 0 7 1 3 5 j=0, i= (2,5) pivote = 5 -1 0 7 1 3 5 -1 0 5 1 3 7 j=4, i= (2,4) pivote = 3 -1 0 5 1 3 7 -1 0 3 1 5 7 j=3, i= (2,3) pivote = 1 -1 0 3 1 5 7 -1 0 1 3 5 7 j=2, i=3, FIN

Ordenación por partición:

quicksort

‣ Coste temporal

‣ n = der - izq + 1^ (tamaño del intervalo a ordenar) ‣ Una parte de los pasos se realizan dentro de la propia llamada: inicialización y ciclo principal ‣ Pero al tratarse de un algoritmo recursivo, hay que contabilizar también los pasos que se realizan dentro de las llamadas recursivas (que pueden ser dos, una o ninguna) ‣ t(n) = 1 + tcp(n) + t(k) + t(n-k)^ (caso general) ‣ t(1) = 1^ (caso base: los tramos de tamaño 1 ya están ordenados) ‣ Se puede demostrar que el número de comparaciones, incrementos/ decrementos e intercambios en el ciclo principal es proporcional a n: tcp(n) = an + b* ∈ Θ(n)

Ordenación por partición:

quicksort

n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 n/ n/4 n/4 n/4 n/ n/ n n n n log n ....... n n Θ(n log n) Esquema del mejor caso

Ordenación por partición:

quicksort

Esquema del peor caso n 1 1 1 n− 1 n− 2 n− 3 2 1 1 ....... n n n− 1 n− 2 2 3 n ∑n i= i + n − 1 = 1 2 n 2

3 2 n − 1 ∈ Θ(n 2 )