Algoritmos y Estructuras de Datos III

Facultad de Inform
atica, Grupo 2B
Universidad Polit
ecnica de Valencia

Tema 1:
Divide y Vencer
as
Selecci
on del N-
esimo mnimo
Enrique Vidal Ruiz
evidal@iti.upv.es
Octubre, 2000

E. Vidal UPV

AD3-D&V/Select-1.4

Octubre, 2000

Divide y Vencer
as (D&V): Indice

1. Introduccion: Busqueda Dicotomica

2. Esquema General de D&V y Propiedades
3. Algoritmos de Ordenacion: MergeSort y QuickSort
4. Seleccion del N-esimo mnimo
5. Otros algoritmos de D&V

E. Vidal UPV

Pagina 1.4.1

AD3-D&V/Select-1.4

Octubre, 2000

Selecci
on simple por intercambio ((N n), O(n2)),
por ordenaci
on (n log n) y por partici
on (O(n))
/*
Programa de prueba de algoritmos de Selecci
on
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

*/

#define maxTalla
4096
int v[maxTalla];
/* v[0..4095]
/* ---------------------------------------------------------------------Inselec Selecci
on por b
usqueda exhaustiva -- peor caso cuadr
atico
*/
int inSelec(int p, int r, int i) {
/* [ 0<p<=r<maxVec, 1<=i<=r-p+1 ]
int j, k, q, menor, aux;
for (k = 1; k <= i; k++) {
/* buscamos los i primeros m
nimos
q = p+k-1; menor=q;
for (j = q+1; j <= r; j++) if (v[j] < v[menor]) menor=j;
aux=v[q]; v[q]=v[menor]; v[menor]=aux;
/* intercambio
}
return(v[p+i-1]);
}
E. Vidal UPV

*/

*/
*/

*/

Pagina 1.4.2

AD3-D&V/Select-1.4

Octubre, 2000

/* ----------------------------------------------------------------------QuickSort -- coste promedio O(n log(n)), peor caso O(n2)

*/
int separa(int p, int r) { /* obtiene un "pivote" q, p<=q<r y separa los */
int i,j,x,z,n;
/* elementos de v tal que v[p..q] <= v[q+1..r] */
x=v[p]; i=p-1; j=r+1;
while (1) {
do j--; while (v[j]>x);
do i++; while (v[i]<x);
if (i<j) { z=v[i]; v[i]=v[j]; v[j]=z; }
else return(j);
}

/* intercambio */

void qks(int p, int r) {

/* [ 0<p<=r<maxVec ] Algoritmo quickSort */
int q;
/* si p>=r, s
olo hay 0
o 1 elementos y ya est
an ordenados */
if (p<r) {
q=separa(p,r); qks(p,q); qks(q+1,r);
}
}
E. Vidal UPV

Pagina 1.4.3

AD3-D&V/Select-1.4

Octubre, 2000

/* ---------------------------------------------------------------------Selecci
on por divide/vencer
as basada en partici
on -- Coste medio O(n)
*/
int partSelec(int p, int r, int i) {
/* [ 0<p<=r<maxVec, 1<=i<=r-p+1 ] */
int m,q;
if (p==r) /* && (i==1) */ return(v[p]);
q=separa(p,r);

m=q-p+1;

/* precondici
on:

p=r ==> i=1 */

/* p <= q < r ; m = |v[p..q]| */

/* los m menores elementos est
an en v[p..q] */

if (i<=m) return(partSelec(p,q,i));
else
return(partSelec(q+1,r,i-m));

/* (i<=m && q<r) ==> i<=q-p+1 */

/* (i>m && q<r) ==>
*/
/*
1<=i<=r-(q+1)+1 */

E. Vidal UPV

Pagina 1.4.4

AD3-D&V/Select-1.4

Octubre, 2000

/* =======================================================================
Lectura de datos e invocaci
on algoritmo
*/
void main() {
int i,j,N,M, vv, indDat, algor; int w[maxTalla];
printf("Prueba de algoritmos de selecci
on "
"(N-best) [0=inSelec, 1=qks, 2=partSel] \n");
printf("Introduce valores a considerar (fin con ^D):\n\n");
j=0; while ((scanf("%d", &vv) != EOF) && (j<=maxTalla)) w[j++]=vv;
indDat=j-1;
printf("\n");

E. Vidal UPV

Pagina 1.4.5

AD3-D&V/Select-1.4

Octubre, 2000

/* ----------------------------------------------------------------------Especificaci
on de N y del Algoritmo a usar e invocaci
on del mismo
*/
do {
printf("Valor de N (N-
esimo m
nimo) y Algoritmo [0, 1, 2]): ");
if ((scanf(" %d %d", &N, &algor) == EOF) || (N<1) || (N>maxTalla)) break;

for (i=0; i<=indDat; i++) v[i]=w[i]; /* copia del vector original en v */

switch(algor) {
case 0: M= inSelec(0,indDat,N); break;
case 1: qks(0,indDat); M=v[N-1]; break;
case 2: M=partSelec(0,indDat,N); break;
default: printf("Algoritmo %1d desconocido", algor);
}
printf("\nN-
esimo m
nimo: %d; Contenido del vector:\n", M);
for (i=0; i<=indDat; i++) { printf("%6d",v[i]);
if (i==N-1) printf("*"); else printf(" "); if (i%10==9) printf("\n");
} printf("\n\n");
} while(1);
printf("\n");
}
E. Vidal UPV

Pagina 1.4.6

AD3-D&V/Select-1.4

Octubre, 2000

Selecci
on del N-
esimo mnimo por D&V: Traza
Instancia: v = [55, 33, 22, 66, 44, 11, 33, 77]; N = 3
Vector ordenado: v 0 = [11, 22, 33, 33, 44, 55, 66, 77]

Selec(1, 8, 3)
Separa(1, 8) = 5
Selec(1, 5, 3)
Separa(1, 5) = 2
Selec(3, 5, 1)
Separa(3, 5) = 3
Selec(3, 3, 1)

E. Vidal UPV

55
33

33
33

22
22

66
11

44
44

11
66

33
55

77
77

33
11

33
22

22
33

11
33

44
44

33
33

33
33

44
44

33

Pagina 1.4.7

AD3-D&V/Select-1.4

Octubre, 2000

Prestaciones de 3 t
ecnicas de selecci
on con datos (short) aleatorios
# Inst. aleatorias; algoritmos:
# N-esimo minimo, N <= talla (N
#
for t in 100 1000 10000 100000 ;
echo -n "
" ; selectime -a
done ; done ; echo

2=partSelect, 1=qks, 0=inSelect,

~= talla/2, en promedio)
do echo ; for a in 2 1 0 ; do
$a -t $t -n 4096000 -T 60

a=2 N=100
a=1 N=100
a=0 N=100

t=100
t=100
t=100

: Procesadas 918055 instancias en

: Procesadas 233840 instancias en
: Procesadas 144504 instancias en

60.00 segundos
60.01 segundos
60.01 segundos

a=2 N=1000
a=1 N=1000
a=0 N=1000

t=1000
t=1000
t=1000

: Procesadas 110275 instancias en

: Procesadas 17705 instancias en
: Procesadas
1597 instancias en

60.00 segundos
60.00 segundos
60.03 segundos

a=2 N=10000
a=1 N=10000
a=0 N=10000

t=10000
t=10000
t=10000

: Procesadas
: Procesadas
: Procesadas

60.00 segundos
60.04 segundos
62.80 segundos

a=2 N=100000 t=100000 : Procesadas

a=1 N=100000 t=100000 : Procesadas
a=0 N=100000 t=100000 : Procesadas
E. Vidal UPV

11105 instancias en
1335 instancias en
15 instancias en

1008 instancias en 60.00 segundos

111 instancias en 60.54 segundos
1 instancias en 527.68 segundos
Pagina 1.4.8

AD3-D&V/Select-1.4

Octubre, 2000

# Inst. aleatorias; algoritmos: 2=partSelect, 1=qks, 0=inSelect,

# N-esimo minimo, N <= 5 (N ~= 2.5, en promedio)
#
for t in 100 1000 10000 100000 ; do echo ; for a in 2 1 0 ; do
echo -n "
" ; selectime -a $a -t $t -n 4096000 -T 60 -N 5
done ; done ; echo
a=2 N=5
a=1 N=5
a=0 N=5

t=100
t=100
t=100

: Procesadas 1263742 instancias en

: Procesadas 234319 instancias en
: Procesadas 1496785 instancias en

60.00 segundos
60.01 segundos
60.00 segundos

a=2 N=5
a=1 N=5
a=0 N=5

t=1000
t=1000
t=1000

: Procesadas
: Procesadas
: Procesadas

164317 instancias en
17544 instancias en
173162 instancias en

60.00 segundos
60.01 segundos
60.01 segundos

a=2 N=5
a=1 N=5
a=0 N=5

t=10000
t=10000
t=10000

: Procesadas
: Procesadas
: Procesadas

17218 instancias en
1410 instancias en
16382 instancias en

60.00 segundos
60.02 segundos
60.00 segundos

a=2 N=5
a=1 N=5
a=0 N=5

t=100000 : Procesadas
t=100000 : Procesadas
t=100000 : Procesadas

1674 instancias en
117 instancias en
1643 instancias en

60.01 segundos
60.22 segundos
60.03 segundos

E. Vidal UPV

Pagina 1.4.9