-

Final/1C 2007

+EJERCICIO 2
+
+GetMax
+
+Max-Heap: Con proximo, me cuesta O(1)\
+
+Min-Heap: representado en un array, solo debo comparar los elementos de la mitad hasta el final del heap, eso seria O(n/2) = O(n), tambien recorro todos los nodos del arbol, teniendo asi una complejidad del orden de O(n).
+
+GetMin
+
+Analogo a GetMax
+
+SacarMin
+
+MinHeap: utilizando la funcion desencolar, obtengo rapidamente un arbol sin su raiz, que en este caso es el minimo que yo quiero sacar.La funcion desencolar utiliza en la implementacion la funcion bajar que lo que hace es buscar el lugar correcto de un nodo en un heap. Funciona de la siguiente manera:
+	En la implementacion, se obtiene en O(1) la posicion del ultimo nodo colocado en el heap, y por implementacion, ya se tienen un puntero a la raiz, entonce se hace un swap de esos nodos O(1). Luego, elimino e ultimo nodo que solia ser la raiz O(1). Ahora tengo un arbol donde una mitad no fue tocada y sigue cumpliento el invariante, y otra que fue modificada y tengo que volver a modificarla de forma tal de obtener un heap nuevamente, aca es donde aparece la funcion bajar, lo que hace esta funcion es, se fija si el nodo es una hoja y si tiene menor prioridad que sus hijos, si los dos se cumples o no se cumple el primer, listo, ese nodo esta en su lugar, si no se cumple lo segundo, intercambia el nodo con el hijo de menor prioridad. como ambos sub arboles de la raiz son heaps, y el nodova a bajar por un solo sub arbol haciendo comparaciones,, en el peor de loso casos, va a comparar O(k) veces, siendo k la altura del sub arbol, que al ser binariio y balanceado, es logn.
+
+Max-Heap: Ya dijimos que encontrar el minimo en un Max-Heap cuesta O(n), eliminarlo, costaria un orden de O(1), pero luego debo reconstruir el invariante de representacion, eso con el algoritmo de Floyd, me tomaria O(n).
+
+SacarMax
+
+Analogo a SacarMin
+
+
+Heaps vs AVL
+
+Para estas funciones, es mejor utilizar un heap, porque aunque en la practica un AVL, haga sus operaciones en O(logn), en la teoria, suele ser en el peor caso O(3logn) y eso en terminos de memoria y tiempo no es conveniente. Asi es que es mejor obtener un min/max heap dependiendo de lo que se precisa, que un AVL

Final/2C 2007

+EJERCICIO 1 
+
+Si en una especificación tengo funciones inconsistentes, que violan la congruenccia etc., Corro el riesgo de no tener una representación completa de mi problema, generando 
+
+
+
+
+EJERCICIO 3
+
+Deberia ver bien el siagrama, pero si los nodos unicamente tienen las claves del diccionario, sin ninguna info mas, no seria muy eficiente la forma mas eficiente de haerlo es con una tabla de Hash, esta es un arreglo de conj<tuplas<a,b>> (a = claver, b= significado) junto con una funcion llamada funcion de hashing. Esta me permite buscar claves en un diccionario en O(1) si esta bien implementada, miientras que al tener nodos con punteros, seguramente se podra buscar una clave en O(n) o si era un arbol balanceado O(logn).
+
+Como buscan las tablas de hash?
+
+Hay dos tipos de tablas, las que tienen conjuntos de =1 elementos y las que en cada posicion del arreglo tienen conjunto de 1 unico elemento. 
+Las que tienen +1 elemento en el arreglo, para buscar, yo puedo acceder a la posicion en O(1) y luego debo buscar en el conjunto, la idea es tener una funcion de hash que no mande a todo en el mismo lugar y que sea dependiendo el factor de carga, esste es el tamanio del arreglo/ la cantidad de cosas que tengo. Asi la busqueda en la posicion es de O(fc) = O(cte) = O(1), lugo buscar algo es en O(1)
+
+La segunda tabla, cunado hay una colision, debo encontrar un nuevo lugar, y para hacer eso uso mis funciones de hash de distintas formas, lineal, cuadratica o doble. Donde es todo mas simple y se puede hacer todo en O(1).
+
+
+EJERCICIO 4
+
+HeapSort 
+
+La forma de ordenar un arreglo mediante heap sort es utilizando la funcion heapify. El algoritmo es el siguiente:
+for ...
+Me genero un MaxHeap con el conjunto que tengo y el algoritmo de Floyd (O(n))
+for...
+Desencolo la raiz		O(logn)
+La pongo en el ultimo lugar de un arreglo,	O(1)
+Me creo otro maxHeap 		O(n)
+
+=O(n+1nlogn) = O(n+logn)
+
+MergeSort
+
+Teorema maestro
+
+
+EJERCICIO 5
+
+Igualdad(1,2) -> bool
+es=false
+if(|a|==|b|){
+	if(a.raiz==b.raiz){
+		fddgdfjd
+
+Igualdad(a.Subderecho
+
+
+
+
+
+
+
+
+

Final/2C 2012

+EJERCICIO 1
+
+Bucket	
+
+Lo que hago es dividir los parciales por la cantidad de profesores, alli cada uno va a tener una cantidad de parciales similar para ordenar. Luego cada uno debe ordenar su montoncito separando en max 27 montoncicitos ( uno por cada letra) y despues se juntan y por cada montoncito de cada uno van ordenando otra vesx con radix 
+
+O(500+|apellidolargo|m+
+O9m)
+
+Pongo por cada letra un montoncito, en probabilidad habria 18 parciales por cada nombre. 26/m y le doy esa cantidad de montoncitos a cada profesor. Con radix lo ordenan, y luego los unen uno por uno en el orden debido
+
+O(1+1+1+f/cxm+1)= O(m)

Final/Diseño

+Rep
+
+Nos indica si la estructura (el diseño) es valido para representar una instancia del tipo. Es lo que nos da el comportamiento de las operaciones para funcionar correctamente. NOS DICE SI LA ESTRUCTURA ESTA BIEN CON RESPECTO AL TIPO Y NO TIENE NINGUNA INCONGRUENCIA PARA NINGUNA INSTANCIA. SE CUMPLEN EN TODAS LAS INSTANCIAS.
+
+El dominio del Rep es la imagen funcional del tipo a implementar. 
+
+Abs
+
+Va de la imagen funcional de la estructura, a la imagen funcional del tipo. T representa a A si Abs(T)=A
+
+Los que hace la funcion de abstración, es darnos una igualdad entre todas las cosas que cumplen la estructtura contra el tipo. Si cumple la estructura, entonces debe cumplir los observadores del tipo. 
+
+Nos hace falta que sea suryectiva porque por la forma en la que esta escrita, no se pueden distinguir dos instancias observacionalmente iguales, entonces no podemos decir que todo termino de un TAD es imagen de Abs para una estrucutra
+
+TIENE QUE SER SOBREYECTIVA SOBRE LAS CLASES DE EQUIVALENCIA PORQUE SI NO LO FUERA HABRIA ELEMENTOS DEL TIPO QUE NO PODRIAN SER REPRESENTADOS

Final/Invariante de Representacion

+EJERCICIO 4
+
+El invariante de representación cumple la función de determinar si nuestra estructura cumple con todas las instancias del tipo, nos da el comportamiento de la estructura con respecto al tipo. Es el que nos dice si una estructura cumple o no con las instancias y no genera incongruencia en sus operaciones. 
+
+Rep: diseño(con gorrito) -> boolean
+
+Lo bueno de tener un invariante de representación es que nos une el comportamiento de la estrucutura con la del tipo. Nos ayuda a darnos cuenta si todas las instancias estan representadas por mi estructura. Sirve por ejemplo, cuando queremos hacer una implementación de un tipo, no generar congruencias.
+
+
+Abs no es necesariamente  es  suryectiva  sobre  el  conjunto  de  t ́erminos  de  un  TAD.  Por  la  forma  en  la  que  Abs  es construida no es posible diferenciar entre instancias de un TAD que son observacionalmente iguales y por lo tantono es posible garantizar que todo t ́ermino del TAD es imagen de Abs para alguna estructura de representaci ́on
+
+Por la forma en la Abs esta construida, no se puede diferenciar instancias que son observacionalmente iguales, es por eso que no podemos asegurarnos de que vamos a representar absolutamente todas las instancias de un TAD que pertenezcan a la misma clase de equivalencia. Es decir, que nada nos asegura que todos los terminos de un TAD son imagenees del Abs.

Final/Tablas de Hash

+Las tablas de hash son efectivas para implementar diccionarios
+
+En el peor caso, buscar algo en una tabla de hash es O(n) pero en tiempo promedio, es O(1)
+
+Se asocia a cada valor de la clave un indice de un arreglo, por lo tanto buscar, insertar y eliminar es en O(1)
+
+Direccionamiento cerrado(El lindo)
+
+Busqueda= O(longitud de la lista asociada)
+Inserción= O(1)
+Borrado = O(longitud de la lista asociada)
+
+Si mantenemos la tería de Uniformidad Simple, la busqueda fallida sería en Theta(1+a) y la busqueda exitosa en Theta(1+a/2)