Estructuras de Datos

Estructuras de Datos
Material Elaborado por el Profesor Ricardo González
A partir de Materiales de las Profesoras
Angela Di Serio
Mariela Curiel
Estructuras de datos
Los programadores de lenguaje ensamblador piensan
en término de datos simples: caracteres, enteros,
números en punto flotante. Sin embargo, mientras
más complejo es el problema que deseamos
resolver, las estructuras de datos dejan de ser
simples y se hace necesario emplear estructuras
más elaboradas como los arreglos, Strings, Clases,
listas, pilas y árboles. Cada una de estas
abstracciones pueden construirse a partir de
elementos más simples como lo son: direcciones de
memoria, caracteres, enteros y números en punto
flotante
Objetos
Para los propósitos de esta clase consideraremos que
un objeto es una abstracción en la que se especifica
una estructura de datos y las operaciones que
permiten operar con dicha estructura de datos.
La creacción de la estructura en si se realiza con la
llamada al constructir de la clase (new), en este
momento es que se reserva espacio de memoria
para almacedar los datos que contiene el objeto. La
referencia a los objetos se realiza al asignar
apuntadores a las direcciones de las estructuras.
Ejemplo 1 de un objeto
Clase Point
Point origen_uno =>
Public clas Point {
origen_uno
public int x=0;
public int y=0;
public Point(int x, int y) {
this.x = x;
this.y = y;
Cuando hacemos un new lo que ocurre es:
}
Point origen_uno = new Point(23, 50);
}
x
origen_uno
y
23
30
Objeto Point
Ejemplo 1 de un objeto
Clase Point
X Y
X
Objeto p
Y
p
p = new Point( a, b)
lw
lw
li
li
syscall
move
sw
sw
sw
$t3, a
$t4, b
$a0, 8
$v0, 9
$t5, $v0
$t3, 0 ($t5)
$t4, 4 ($t5)
$t5, p
p.getY()
lw
lw
move
jr
$t2, p
$t3, 4 ($t2)
$v0, $t3
$ra
Ejemplo 2 de un objeto
Clase Rectangle
x
Public clas Rectangle{
public int width;
public int height;
public Point origin;
y
origen_uno
Cuando hacemos un new
lo que ocurre es:
23
30
public Rectangle(Point
p,int x, int y) {
origin = p;
Rectangle origen_uno = new Rectangle(origen_uno, 23, 50);
width = x;
height = y;
width
23
}
}
height
rectangulo
origin
Objeto Rectangle
30
Ejemplo 2 de un objeto
Clase Rectangle
alto
Rectangle(Point p, int a, int l )
largo
Objeto r1
r1
r1 = new Rectangle( p1, a1, l1)
lw
lw
lw
li
li
syscall
move
sw
sw
sw
sw
$t2, p
$t3, a
$t4, l
$a0, 12
$v0, 9
$t5, $v0
$t2, 0 ($t5)
$t3, 4 ($t5)
$t4, 8 ($t5)
$t5, r1
alto
largo
X
Y
Ejemplo 2 de un objeto
r2
alto
largo
X
Y
r2 = new Rectangle ( int x, int y, int a, int l)
lw
lw
lw
lw
li
li
syscall
move
sw
sw
li
li
syscall
move
sw
sw
sw
jr
$t0, x
$t1, y
$t2, a
$t3, l
$a0, 8
$v0, 9
$t5, $v0
$t0, 0 ($t5)
$t1, 4 ($t5)
$a0, 12
$v0, 9
$t6, $v0
$t5, 0 ($t6)
$t2, 4 ($t5)
$t3, 8 ($t5)
$ra
Pilas
B
Una pila es una estructura de datos que permite
implementar la disciplina FILO (First In Last Out)
Para utilizar la pila se emplean al menos dos valores
diferentes, uno para indicar la direccion de la pila y
otro para el tope o último elemento incluido en la
pila.
C
B
A
A
Si la pila crece de las direcciones altas a las
direcciones bajas de la memoria .
X
apilar ( X )
B
tope
A
lw
subi
lw
sw
$t0, tope
$t0, $t0, 4
$t1, X
$t1, 0($t0)
tope
B
A
pila
pila
desapilar ( )
B
tope
A
pila
lw
lw
addi
jr
$t0, tope
$v0, 0 ( $t0 )
$t0, $t0, 4
$ra
A
tope
pila
Pilas
Si los datos a
almacenar en la pila
son de longitud
variable y/o no se
sabe a priori el
tamaño de los nodos a
incluir en la pila, es
posible que se
requieran otras
estructuras para
manejar la pila.
$sp
Variables
Locales
$fp
Registros
Guardados
...
Argumento 6
$sp
$fp
Argumento 5
Variables
Locales
Variables
Locales
Registros
Guardados
Registros
Guardados
...
...
Argumento 6
Argumento 6
Argumento 5
Argumento 5
Colas
Una cola es una estructura de datos que permite implementar la disciplina
FIFO (First In First Out)
Para utilizar la cola se emplean al menos dos valores diferentes, uno para
la cabeza de la cola y otro para el final, cola o extremo de la cola.
Memoria
Memoria
6
extremo
cabeza
1
2
2
3
3
4
4
5
5
6
cabeza
1
extremo
6
extremo
7
Agregar(7)
5
4 3 2 1
cabeza
Arreglos de una dimensión (vectores)
Los arreglos son colecciones ordenadas de datos que poseen el
mismo tipo y formato de datos en sus elemenos constitutivos.
Memoria
V
7
3
9 2 4 5
V[0] V[1] V[2] V[3] ,V[4] V[5]
7
V+0
3
V+4
9
V+8
2
V + 12
4
V + 16
5
V + 20
Arreglos de dos dimensiones (matrices)
0
1
Memoria
M[0,0]
1
M[0,1]
5
M[0,2]
0
1
2
3
1
9
5
3
6
1
3
4
Memoria
M[0,0]
1
M[1,0]
9
6
M[0,1]
5
M[0,3]
3
M[1,1]
3
M[1,0]
9
M[0,2]
6
M[1,1]
3
M[1,2]
1
M[1,2]
1
M[0,3]
3
4
M[1,3]
4
M[1,3]
Fila 0
Fila 1
Almacenamiento por filas
Columna 0
Columna 1
Columna 2
Columna 3
Almacenamiento por columnas
Arreglos de dos dimensiones (matrices)
Memoria
M
M[0,0]
1
M[0,1]
5
M[0,2]
6
M[0,3]
3
M[1,0]
9
M[1,1]
3
M[1,2]
1
M[1,3]
4
Fila 0
Para calcular el desplazamiento de
un elemento con respecto al origen
de la matriz, se emplea la
siguiente fórmula
Fila 1
Almacenamiento por filas
Dir efectiva = Dirección de M +
( fila i * número de elementos en una fila * tamaño de un elemento ) +
( columna j * tamaño de un elemento )
M
M[0,0,0]
M[0,0,1]
M[0,0,2]
M[0,0,3]
M[0,1,0]
M[0,1,1]
M[0,1,2]
M[0,1,3]
M[1,0,0]
M[1,0,1]
M[1,0,2]
M[1,0,3]
M[1,1,0]
M[1,1,1]
M[1,1,2]
M[1,1,3]
Matrices multidimensionales