Repaso/resumen Capítulo 3. Listas y tablas de valores Listas Tablas (listas de listas) Diccionarios y Tuplas Búsqueda: algoritmos O(n) y O(log2n) Ordenamiento: algoritmos O(n2) y O(nlog2n) Capítulo 4. Tipos de datos abstractos y Estructuras de Datos Tipos de datos abstractos

o Stack, Queue, Diccionario o excepciones

Estructuras de datos o Listas enlazadas o Árboles binarios

Capítulo 5: Computación científica (en Matlab y Python) Problemas: polinomio, área, raíz, sistema ecuaciones lineales,

multiplicación de matrices

Listas L=[…]; L1=[…] Funciones que devuelven un valor L.count(x) #n° de veces que aparece x en L L.index(x) #indice de 1a aparición de x L.__contains__(x) # x in L L.__add__(L1) #L+L1: nueva lista añadiendo elementos L.__mul__(n) #L*n es decir L + L + …L (n veces) L.__getslice__(i,j) #L[i:j] L.__lt__(L1) #L<L1 Funciones que modifican la lista L.remove(x) #elimina primer x de la lista L.insert(i,x) #inserta x en lugar de índice i L.pop(i) #elimina (y entrega) el elemento de índice i L.append(x) #agrega al final de L L.extend(L1) #extiende L con elementos de lista L1 L.reverse() #invierte los elementos de L L.sort() #ordena los elementos de L L.__setslice__(i,j,L1) #L[i,j]=L1 L.__iadd__(x) #L+=L1

Diccionarios, Listas y Tuplas D={"hola":1,"chao":2} Lista con tuplas (pares) de los ítems del diccionario D.items() [('chao', 2), ('hola', 1)] #recorrer pares for (llave,valor) in D.items(): print llave, valor Lista con llaves/identificadores del diccionario D.keys() ['chao', 'hola'] #orden arbitrario Lista con valores de las llaves del diccionario D.values() [2, 1] #orden paralelo a D.keys() Equivalencia L=D.items() y L=zip(D.keys(),D.values())

Búsqueda de un objeto en una lista de objetos #Búsqueda secuencial: O(n) def indice(x,lista): #O(n) for i in range(len(lista)): if lista[i]==x: return i return -1 #Búsqueda binaria: O(log2n) def indice(x,lista,ip,iu): if ip>iu: return –1 im=(ip+iu)/2 if x<lista[im]: return indice(x,lista,ip,im-1) if x>lista[im]: return indice(x,lista,im+1,iu) return im

Ordenamiento def quicksort(x,ip,iu): if ip>=iu: return i=particionar(x,ip,iu) quicksort(x,ip,i-1) quicksort(x,i+1,iu) def particionar(x,ip,iu): pivote=x[ip]; i=ip for j in range(ip+1,iu+1): if x[j]<pivote: i=i+1; x[i],x[j]=x[j],x[i] x[ip]=x[i]; x[i]=pivote return i

Archivos de acceso directo: quicksort(open(“…”,”r+”),0,n-1) def particionar(x,ip,iu): pivote=leerRegistro(x,ip); i=ip for j in range(ip+1,iu+1): if leerRegistro(x,j)<pivote: i=i+1; intercambiar(x,i,j) intercambiar(archivo,ip,i); return i def leerRegistro(x,i): x.seek(i*LargoReg); return x.read(LargoReg) def escribirRegistro(x,reg,i): x.seek(i*LargoReg); return x.write(reg) def intercambiar(x,i,j): ri=leerRegistro(x,i); rj=leerRegistro(x,j) escribirRegistro(rj,x,i); escribirRegistro(ri,x,j) def indice(x,archivo,ip,iu): #busqueda binaria if ip>iu: return -1 im=(ip+iu)/2; registro=leerRegistro(archivo,im) if x<registro: return indice(x,archivo,ip,im–1) if x>registro: return indice(x,archivo,im+1,iu) return im

TDA Stack (operaciones públicas, representación privada/oculta) Operación significado explicación s=Stack()

crear stack vacío

s.push(x)

x

Poner x en stack. Si está lleno produce la excepción StackFull

s.pop( )

Sacar un valor de stack. Si está vacío produce la excepción StackEmpty

s.reset( )

vaciar stack

s.empty( ) ¿ ?

True si stack está vacío

s.full( ) ¿ ?

True si stack está lleno

TDA Stack: implementación con una lista

A B C L L[0] L[1] L[2] class Stack: def __init__(self): self.L=[] def empty(self): return len(self.L)==0 def full(self): return False def reset(self): self.L=[] def push(self, x): try: self.L.append(x) # poner al final except MemoryError: raise StackFull() def pop(self): try: return self.L.pop() # sacar del final except IndexError: raise StackEmpty()

class StackEmpty (Exception): def __init__(self): pass class StackFull (Exception): def __init__(self): pass

TDA Stack: representación con lista enlazada C B A None primero valor sgte valor sgte valor sgte class Nodo: def __init__(self,x,y): self.valor=x; self.sgte=y class Stack: def __init__(self): self.primero=None def empty(self): return self.primero==None def full(self): return False def reset(self): self.primero=None def push(self, x): try: self.primero=Nodo(x,self.primero) except MemoryError: raise StackFull() def pop(self): try: v=self.primero.valor self.primero=self.primero.sgte return v except AttributeError: raise StackEmpty()

TDA Queue: Representación con lista enlazada A B C None

p valor sgte valor sgte sgte class Queue: u def __init__(self): self.reset() def reset(self): self.p=None; self.u=None def empty(self): return self.p==None def full(): return False def enque(self,x): try: nuevo=Nodo(x,None) except MemoryError: raise QueueFull() if self.empty(): self.p=self.u=nuevo else: self.u=self.u.sgte=nuevo #enlazar a último def deque(self):

try: v=self.primero.valor #recuperar primer valor except AttributeError: raise QueueEmpty() if self.p==self.u: self.p=self.u=None #caso 1 Nodo else: self.p=self.p.sgte #eliminar el 1° return v #devolver primer valor

TDA Diccionario: lista ordenada de palabras con significados. Operación Significado D.Buscar(x) devolver significado de palabra x. Excepción NoExiste D.agregar(x,y) agregar palabra x con significado y. Exs: YaExiste, Lleno D.borrar(x) borrar palabra x. Excepción NoExiste D.cambiar(x,y) cambiar significado de palabra x por y. Ex: NoExiste Representación con ABB (Arbol Binario de Búsqueda) class Nodo: def __init__(self,x,y,z=None,w=None): self.palabra=x;self.significado=y;self.izq=z;self.der=w class Diccionario: def __init__(self): self.raiz=None def buscar(self,x):r=ref(x,self.raiz);return r.significado def cambiar(self,x,y): r=ref(x,self.raiz); r.significado=y global ref, arbolConX, arbolSinX, arbolNuevo def ref(x,r): if r==None: raise NoExiste() if x==r.palabra: return r elif x<r.palabra: return ref(x,r.izq) else: return ref(x,r.der)

def agregar(self,x,y): self.raiz=arbolConX(x,y,self.raiz)

def arbolConX(x,y,r): if r==None: try: return Nodo(x,y) except MemoryError: raise Lleno() elif x==r.palabra: raise YaExiste() elif x<r.palabra: r.izq=arbolConX(x,y,r.izq) else: r.der=arbolConX(x,y,r.der) return r def borrar(self,x): self.raiz=arbolSinX(x,self.raiz) def arbolSinX(x,r): if r==None: raise NoExiste() elif x==r.palabra: return arbolNuevo(r) elif x<r.palabra: r.izq=arbolSinX(x,r.izq)

else: r.der=arbolSinX(x,r.der) return r def arbolNuevo(r):

Matlabones(1,5); %1 1 1 1 1zeros(1,5); %0 0 0 0 01:5; %1 2 3 4 51:2:9; %1 3 5 7 9linspace(0,1,5) ; %0 0.2500 0.5000 0.7500 1.0000rand(1,5); %0.xxxx 0.xxxx 0.xxxx 0.xxxx 0.xxxx

a=[1 2 ; 3 4];

a(2,2); %4 matriz(nºfila,nº columna)

a(1,: ); %fila 1

a(:,2); %columna 2

a(2,2:end); %2ª a última columna de fila 2

a*a; %[7 9; 15 22] multiplicación de matrices

a.*a;%[1 4;9 16] punto a punto

Evaluar polinomio

Matlab %pol(a,x): polinomio de coefs a en argumento x function y=pol(a,x) exponentes=0:length(a)-1; %[0,1,…,n-1] potencias=x.^exponentes; %[x^0,…,x^(n-1)] productos=a.*potencias;%[a(1)*x^0,...,a(n)*x^(n-1)] y=sum(productos); %productos(1)+...+productos(n)

Python def pol(a,x):

suma=0.0 potencia=1 for i in range(0,len(a)):

suma += a[i]*potencia potencia *= x

return suma

Area bajo la curva de función f en intervalo [a,b] x=linspace(a,b,n); plot(x,f(x)) Método de Simpson: (Δ/3)*(y1+4y2+2y3+4y4+2y5+...+yn) function r=area(a,b,n) x=linspace(a,b,n); y=f(x); delta=(b-a)/(n-1); p=y(2:2:n-1); i=y(3:2:n-1);%pares e impares r=delta/3*(y(1)+4*sum(p)+2*sum(i)+y(n)); function r=area(a,b,n) delta=(b-a)/(n-1); p = f(a+delta : 2*delta : b-delta); i = f(a+2*delta : 2*delta : b-delta); r=delta/3*(f(a)+4*sum(p)+2*sum(i)+f(b)); Python def area(a,b,n,f): sp=0; si=0; delta=(b-a)/(n-1) for x in range(a+delta,b-delta,2*delta): sp+=f(x); si+=f(x+delta) return delta/3*(f(a)+4*sp+2*si+f(b))

Raiz de función continuaMatlabfunction r=raiz(a,b,eps)x=(a+b)/2;if b-a <= eps r=x;elseif f(x)*f(a) >= 0 r=raiz(x,b,eps);else r=raiz(a,x,eps);endPython:def raiz(f,a,b,eps): x=(a+b)/2.0 if b-a <= eps: return x elif f(x)*f(a)>=0: return raiz(f,x,b,eps) else: return raiz(f,a,x,eps)

Sistema de n ecuaciones linealesa11x1 + a12x2 + ... + a1nxn = b1

. . .an1x1 + an2x2 + ... + annxn = bn

MatlabA=[…; … ; … ]; %matriz de coeficientes a(i,j)B=[nº; nº ; …;nº]; %vector de b(i)X=inv(A)*B; %X=A\B;

PythonA=[[…],…,[…]] #matriz de coeficientes a(i,j)B=[nº, nº , …,nº] #vector de b(i)triangularizar(a,b)x=[0]*nfor i in range(n-1,-1,-1): suma=0.0 for j in range(i+1,n): suma += x[j]*a[i][j] x[i] = (b[i]-suma)/a[i][i]

Multiplicación de matrices

Matlabz=x*y;

Pythondef producto(x,y): filas=len(x);cols=len(y[0]);n=length(y) z=[[0]*cols]*filas for i in range(filas): for j in range(cols): for k in range(n): z[i][j] += x[i][k]*y[k][j] return z

z=producto(x,y)