Repaso/resumen

Captulo 3. Listas y tablas de valores

Listas
Tablas (listas de listas)
Diccionarios y Tuplas
Bsqueda: algoritmos O(n) y O(log2n)
Ordenamiento: algoritmos O(n2) y O(nlog2n)
Captulo 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
Captulo 5: Computacin cientfica (en Matlab y Python)
Problemas: polinomio, rea, raz, sistema ecuaciones lineales,
multiplicacin 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 aparicin de x
L.__contains__(x) # x in L
L.__add__(L1) #L+L1: nueva lista aadiendo 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())

Bsqueda de un objeto en una lista de objetos

#Bsqueda secuencial: O(n)
def indice(x,lista): #O(n)
for i in range(len(lista)):
if lista[i]==x:
return i
return -1
#Bsqueda 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,im1)
if x>registro: return indice(x,archivo,im+1,iu)
return im

TDA Stack (operaciones pblicas, representacin privada/oculta)

Operacin
s=Stack()

significado explicacin
crear stack vaco

s.push(x)

Poner x en stack.
Si est lleno produce la
excepcin StackFull

s.pop( )

Sacar un valor de stack.

Si est vaco produce la
excepcin StackEmpty

s.reset( )

vaciar stack

s.empty( )

? True si stack est vaco

s.full( )

? True si stack est lleno

TDA Stack: implementacin con una lista

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
def
class
def

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

TDA Stack: representacin con lista enlazada

C
B

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: Representacin con lista enlazada

A
B
C
p
valor sgte valor sgte
class
Queue:
u

None
sgte

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.

Operacin
Significado
D.Buscar(x)
devolver significado de palabra x. Excepcin NoExiste
D.agregar(x,y) agregar palabra x con significado y. Exs: YaExiste, Lleno
D.borrar(x)
borrar palabra x. Excepcin NoExiste
D.cambiar(x,y) cambiar significado de palabra x por y. Ex: NoExiste
Representacin con ABB (Arbol Binario de Bsqueda)
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):

Matlab

ones(1,5); %1 1 1 1 1
zeros(1,5); %0 0 0 0 0
1:5; %1 2 3 4 5
1:2:9; %1 3 5 7 9
linspace(0,1,5) ; %0 0.2500 0.5000 0.7500 1.0000
rand(1,5); %0.xxxx 0.xxxx 0.xxxx 0.xxxx 0.xxxx
a=[1 2 ; 3 4];
a(2,2); %4 matriz(nfila,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] multiplicacin 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 funcin f en intervalo [a,b]

x=linspace(a,b,n); plot(x,f(x))
Mtodo 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 funcin continua

Matlab
function 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);
end
Python:
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 lineales

a11x1 + a12x2 + ... + a1nxn = b1
. . .
an1x1 + an2x2 + ... + annxn = bn
Matlab
A=[; ; ]; %matriz de coeficientes a(i,j)
B=[n; n ; ;n]; %vector de b(i)
X=inv(A)*B; %X=A\B;
Python
A=[[],,[]] #matriz de coeficientes a(i,j)
B=[n, n , ,n] #vector de b(i)
triangularizar(a,b)
x=[0]*n
for 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]

Multiplicacin de matrices
Matlab
z=x*y;
Python
def 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)