tema 3. repaso de primero - us

Tema 3. Repaso de primeroAnálisis y Diseño de Algoritmos

ESCUELA TÉCNICA SUPERIOR DE

INGENIERÍA INFORMÁTICA

Departamento de Lenguajes y Sistemas Informáticos

Curso 2010-2011

Análisis y Diseño de Algoritmos 2

Índice

1. Programación genérica 1.1 Definición

1.2 Restricciones

2. Tipos de datos 2.1 Iterable e iterador

2.2 API Java Estándar

3. Tratamientos secuenciales3.1 Tipos

3.2 Clase Iterables

3.3 Clase Ordering

4. Grafos4.1 Concepto

4.2 Tipos

5. Algoritmos5.1 Problema de la bandera holandesa

5.2 Ordenación por selección

5.3 Redistribución por pivote


Tema 3: Repaso de Primero

Programación Genérica


Programación genéricaDefinición

Programación que usa tipos, interfaces, clases ymétodos genéricos.

Ejemplos:

T[ ] a;

Array de un tipo genérico.

public interface Comparable<T>…

Interfaz de tipo genérico.

int compareTo(T e);

Método que recibe un genérico.

public V get(K clave);

Método usando dos genéricos.

¿Cómo se declararía un método que use un tipo genérico distinto a los declarados en la propia clase?


Programación genéricaRestricciones

? Comodín. Cualquier tipo

T1 extends T2 T1 debe ser un subtipo de T2

T1 super T2 T1 debe ser un supertipo de T2

R1 & R2 Conjunción de las restricciones R1 y R2

¿Qué significaría la restriccíón?

<T super Object>

Se usan restricciones para indicar que un tipogenérico no puede ser cualquier tipo.

Las siguientes restricciones son posibles:

¿Es válida la restricción ‘<Integer super T>’ ?

¿Qué significa?


Programación genéricaEjemplos

<T extends Comparable <? super T>>

Declarar un tipo T que implemente Comparable dealgún padre de T. Por ejemplo el tipo ‘Empleado’ queimplementa Comparable de ‘Persona’, dónde ‘Persona’ espadre de ‘Empleado’.

Declarar dos tipos, A y B, que sean padres deSortedSet. Por ejemplo el tipo ‘Set’ y el tipo ‘Collection’ o‘Iterable’ .

Declarar una lista de elementos tipo T queimplementen el tipo ‘Vehiculo’ y otro tipo yadeclarado T1. Una lista de ‘Vehículos’ que, además,implementen otra interfaz con otros métodos.

<A super SortedSet<?>, B super SortedSet<?>>

List<T extends Vehiculo & T1>



Tipos de datos


Tipos de datosIterable e iterador

Interfaz Iterable:

¿Cómo se utiliza el bucle ‘for’ extendido?

Interfaz Iterator:

public interface Iterable<T>{

Iterator<T> iterator();

}

public interface Iterator<T>{

boolean hasNext();

T next();

void remove();

}


Tipos de datosAPI Java Estándar

<<interface>>

Collection <T>

<<interface>>

List <T>

<<interface>>

Set <T>

<<interface>>SortedMap<T1,T2>

<<interface>>

Map <T1,T2>

<<interface>>

SortedSet <T>

<<interface>>

Iterable <T>

<<interface>>

NavigableSet <T>

definidas en: java.util.*



Collection: Agrupación de elementos de un mismo tipo.

public interface Collection<T> extends Iterable<T> {

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(T element);

boolean remove(Object element);

boolean containsAll(Collection<?> c);

boolean addAll(Collection<? extends T> c);

boolean removeAll(Collection<?> c);

boolean retainAll(Collection<?> c);

void clear();

Object[] toArray();

<S> T[] toArray(T[] a);

}



Set: Colección en la que no se permiten elementos repetidos

SortedSet: Conjunto en el que se establece un orden

public interface Set<T> extends Collection<T> {}

¿Qué diferencia existe entre Collection y Set?

public interface SortedSet<T> extends Set<T> {

SortedSet<T> headSet(T toElement) ;

SortedSet<T> tailSet(T fromElement) ;

SortedSet<T> subSet(T fromElement, T

toElement);

T first();

T last();

Comparator<? super T> comparator();

}

¿Cuáles son las dos formas de ordenación de SortedSet?

12


List: Colección en la que los elementos son almacenados enuna posición numérica determinada, respetándose el orden dela posición.

public interface List<T> extends Collection<T> {

T get(int index);

T set(int index, T element);

void add(int index, T element);

boolean remove(Object o);

boolean addAll(Collection<? extends T> c);

int indexOf(Object o);

int lastIndexOf(Object o);

List<T> subList(int fromIndex, int toIndex);

}

¿Cuántos métodos ‘add’ pueden usarse en List?

¿Qué diferencia existe entre SortedSet y List?

13


Map: Agrupación de relaciones entre elementos de dos tipos:claves y valores. No hereda de Collection ni de Iterable.

public interface Map<K,V> {

V put(K key, V value);

V get(Object key);

V remove(Object key);

boolean containsKey(Object key);

boolean containsValue(Object value);

int size();

boolean isEmpty();

void putAll(Map<? extends K,? extends V> t);

void clear();

Set<K> keySet();

Collection<V> values();

}

¿Cuántos métodos ‘add’ pueden usarse en Map?



Tratamientos secuenciales


Tratamientos secuencialesTipos

Dentro de la API de Google pueden encontrarse los tipos: Criterio:

Expresion/Acción

public interface Predicate<T>{

boolean apply(T input);

}

public interface Function<E, S>{

S apply(E input);

}

Google Collections api: http://google-collections.googlecode.com/files/google-collect-1.0.zip

Google Collections docs: http://google-collections.googlecode.com/svn/trunk/javadoc/index.html


Tratamientos secuencialesTipos

Utilizamos Function para implementar una clase Accion. Clase MiAcción de tipo Entero.

public class MiAccion implements Function<Integer, Void>{

Void apply(Integer input){

….

return null;

}

}


Tratamientos secuencialesClase Iterables

Útiles para tratamientos secuenciales de iteradores

public class Iterables {

static <T> boolean all(Iterable<T> i, Predicate<?super T> p){..}

static <T> boolean any(Iterable<T> i, Predicate<?superT> p){..}

static <T> Iterable<T> filter(Iterable<T> i, Predicate<?superT> filtro){..}

static <T> T find(Iterable<T> i, Predicate<?superT> p){..}

static <T1,T2> Iterable<T2> transform(Iterable<T1> i,

Function<?superT1, ?superT2> f){..}

static boolean contains(Iterable<?> i, Object o){..}

static <T> T get(Iterable<T>, int posicion){..}

static <T> int size(Iterable<T> i){..}

}


Tratamientos secuencialesClase Iterables

Utilizando lo anterior, ¿cómo se implementaría el método contador? Cuenta todos los elementos de un ‘Iterable’ ‘it’ que cumplen un ‘Predicate’ ‘p’.

¿Y el método ejecutaParaTodo? Ejecuta una ‘Function’ ‘f’ para cada elemento de un ‘Iterable’ ‘it’

Iterables.size(Iterables.filter(it, p))

Iterables.transform(it,f)


Tratamientos secuencialesClase Ordering

Útiles para uso de órdenes en iteradores

Notar que no hay constructores: Utilizar from, explicit o natural

public class Ordering<T> implements Comparator<T>{

static <T> Ordering<T> from(Comparator<T> comparador){..}

static <T> Ordering<T> explicit(List<T> valoresEnOrden){..}

static <C extends Comparable> Ordering<C> natural(){..}

<T1 extendsT> Ordering<T1> compound(Comparator<?superT1> comparador_2){..}

<T1 extendsT> Ordering<T1> reverse(){..}

<T1 extendsT> Ordering<T1> nullLast(){..} //valores nulos al final

<T1 extendsT> Ordering<T1> nullFirst(){..} //valores nulos al principio

boolean isOrdered(Iterable<?extendsT> i){..}

<T1 extendsT> T1 max(Iterable<T1> i){..}

<T1 extendsT> T1 min(Iterable<T1> i){..}

}


Tratamientos secuencialesClase Ordering

Explicit

Se dispone de una lista de enteros ‘l1’ y se quiere que otras dos listas ‘l2’ y ‘l3’ sigan ese mismo orden ¿Qué orden?

Compound

Ordena una lista ‘l’ de ‘Persona’ por su nombre y, en caso de igualdad, por su apellido.

static <T> Ordering<T> explicit(List<T> valoresEnOrden){..}

Ordering<Integer> orden= Ordering.explicit(l1);

Collections.sort(l2, orden);

Collections.sort(l3, orden);

<T1 extendsT> Ordering<T1> compound(Comparator<?superT1> comparador_2){..}

Ordering<Persona> ordenNombre= Ordering.from(new CompPersonaNombre());

Ordering<Persona> ordenNomApel= ordenNombre.compound(new CompPersonaApellido());

Collections.sort(l, ordenNombreApel);



Grafos


GrafosConcepto

Un grafo consiste en un conjunto de vertices y unconjunto de aristas, en el que cada arista es unelemento que relaciona dos nodos.

vertices

aristas

public interface Graph<V,E> {

public boolean addVertex(V vertice);

public boolean addEdge(V vertice1, V vertice2, E arista);

public E addEdge(V vertice1, V vertice2);

public E getEdge(V vertice1, V vertice2);

public boolean containsEdge(V vertice1, V vertice2);

public boolean containsVertex(V vertice);

public boolean removeEdge(V vertice1, V vertice2);

public boolean removeVertex(V vertice);

}


GrafosEjemplo

N2

N1

N3

V1

V2

Graph<String, String> grafo= new ….;

grafo.addVertex("N1");



grafo.addEdge("N1", "N2", "V1");

grafo.addEdge("N2", "N3", "V2");



Algoritmos


AlgoritmosResolución de problemas

Resolveremos problemas de ‘Transformaciones e Invariantes’: Suresolución consiste en aplicar transformaciones reiteradamentemanteniendo una invariante

Para resolver estos problemas hay que detectar:

Se resolverán dos problemas: Problema de la Bandera Holandesa

Redistribución por pivote

Ordenación por selección

La invariante. (Invariante)

Estado inicial del problema.

Estado final del problema.

Las transformaciones válidas. (Algoritmo)

Función de cota (Se reduce en cada paso)


AlgoritmosProblema de la bandera holandesa

Sea un fila de elementos L y un elemento del mismo tipo denominado pivote. Los elementos de L, pueden categorizarse en los menores que el pivote, los iguales (color blanco) y los mayores. Sea un brazo mecánico capaz de efectuar las operaciones:

T elemento(int i): indica el elemento situado en la posición i.

void permuta(int i,int j): intercambia los elementos de la posición i, con la de la posición j.

Se desea desarrolla un algoritmo iterativo que ordenelos elementos en una sola pasada, colocando primerolos menores, luego las iguales y después los mayores

Estado inicial:

Estado final:

1 5 2 5 1 8 5 4 5 86 5 6

1 2 1 4 5 5 5 8 6 85 5 6

Pivote=5



Resolución en Java:

public class BanderaHolandesa{

public static <T> Par<Integer, Integer> redistribuye(List<T> fila,int posInicial,int posFinal,T pivote,Ordering <? super T> orden){…}

}



Invariante: Existen tres bandas, con los elementos revisados y colocados en su lugar.

(Estas bandas pueden estar vacías)

Existe una banda no revisada comprendida entre dos posiciones. (Esta bandapuede estar vacía)

u v x

En cada estado, existiendo un pivote p, considérense

tres posiciones en la fila: u,v,x. La invariante sería:

posIncial posFinal



Estado inicial Habrá que inicializar el problema para que el estado inicial cumpla la invariante.

Puede fijarse una inicialización para todos los problemas que siempre la cumpla.

Estado final:

u v x

u v x

u v x

30


u v x

u v x

u v x

¿Cuál es la función de cota?Las posiciones devueltas sería u y x

Transiciones: Habrá que analizar la casuística e indicar latransición para cada caso.

Caso en que elemento(v)==p

Caso en que elemento(v)<p

Caso en que elemento(v)>p


AlgoritmosRedistribución por pivote

Sea una fila de elementos L, se desea realizarredistribución de ellos por medio de un pivote. Los quesean mayor que el pivote quedarán a la derecha deeste, y los que sean menores o iguales, a la izquierda.Se disponen de las funciones:

void permuta(int i, int j): intercambia el número de la posición i, con el de la posición j.

E elemento(int i): devuelve el elemento de la posición i-ésima.

public class RedistribucionPivote{

public static <T> Integer redistribuye(List<T> fila,int posInicial, int posFinal,T pivote,Ordering <? super T> orden){…}

}



Invariante Existen dos bandas separadas redistribuida en función de un

pivote p (Pueden estar vacías).

Existe una banda central no redistribuida (Puede estar vacía).

1 1 4 3 3 5 9 2 9 7 6 7 8

u vEn cada estado, habiendo un elemento pivote p, considérense

las posiciones u y v en la fila. La invariante sería:

p=3 1 7 3 2

posIncial posFinal



Estado inicial Las bandas redistribuidas están vacías.

Estado final La banda no redistribuida está vacía.

7 6 1 3 3 5 9 2 9 7 4 1 8

u v

p=3

1 2 1 3 3 5 9 6 9 7 4 7 8

u v

p=3

1 7 3 2

1 7 3 2

34


Transiciones: Habrá que analizar la casuística Caso en que elemento(u)>p && elemento(v-1)<=p

Caso en que elemento(v-1)>p

Caso en que elemento(u)<=p

La posición devuelta es la ‘u’

6 3 1 3 3 5 9 2 9 7 4 7 3

u v

p=3

3 3 1 3 3 5 9 2 9 7 4 7 6

u v

p=3

3 3 1 3 3 5 9 2 9 7 4 7 6

u v

p=3

¿Cuál es la función de cota?

1 7 3 2

1 7 3 2

1 7 3 2

35

AlgoritmosOrdenación por selección

Sea una fila de elementos, se desea realizar unaordenación por selección. Se dispone de:

C elemento(int i): Devuelve el valor de la posición i-ésima.

int buscaMenor(int i, int j): Devuelve la posición del elemento menor comprendido entre la posición i-ésima y la j-ésima.

void permuta(int i, int j): intercambia el número de la posición i, con el de la posición j.

public class OrdenacionSeleccion{

public static <T> void ordena(List<T> fila,int posInicial, int posFinal,Ordering <? super T> orden){…}

}

7 6 1 3 3 5 9 2 9 7 4 1 81 7 3 2

posIncial posFinal



u

En cada estado, considérense la posición u en la

fila. La invariante sería:

1 1 7 3 3 5 9 2 9 7 4 6 81 7 3 2

posIncial posFinal

Invariante: Existen una banda al comienzo de la fila, con los elementos colocados en su

lugar. (Esta banda puede estar vacía)

Existe una banda no ordenada que consiste en el resto de la fila. (Esta bandapuede estar vacía)

37


Estado inicial Habrá que inicializar el problema para que el estado inicial cumpla la invariante.

Estado final Cuando se halla recorrido toda la fila, ésta estará ordenada.

Transiciones: En este problema no hay casuística. Siempre sesustituirá el elemento en ‘u’, por el mínimo de la fila desde ‘u’ hastael final.

u

7 6 1 3 3 5 9 2 9 7 4 1 8

1 1 2 3 3 4 5 6 7 7 8 9 9

u

¿Cuál es la función de cota?

1 7 3 2

1 7 3 2

tema 3. repaso de primero - us

Documents