Transcript Presentación de 21 de marzo 2014 estructura de datos UVM

LOS DATOS A PROCESAR PUEDEN SER:
SIMPLES
Ocupan solo una casilla de memoria. (enteros, reales, caracteres, booleanos).
Ejemplo:
567
COMPLEJOS O ESTRUCTURADOS .- Hacen referencia a un grupo de casillas de memoria y son
construidos a partir de los datos simples.
-Arreglos o vectores, matriz, árboles, registros, archivos, Bases de Datos, etc.
ESTRUCTURA DE DATOS ( ARREGLOS )
ARREGLOS O VECTORES.
ESTRUCTURADOS.- Hacen referencia a un grupo de casillas de memoria
Es una colección finita, homogenea y ordenada de elementos
Finita.- Indica el número máximo
Homogénea.- Son del mismo tipo (entero, reales, caracteres)
Ordenada.- Llevan un orden consecutivo a través de un índice
Ejemplo:
A=
(0)
34
(1)
45
(2)
12
(3)
05
(4)
93
Datos
Índices
ESTRUCTURA DE DATOS ( ARREGLOS )
ARREGLOS UNIDEMENCIONALES O VECTORES.
ESTRUCTURADOS.- Hacen referencia a un grupo de casillas de memoria
Los índices hacen referencia a los componentes (datos) en forma individual.
Ejemplo:
A=
(0)
34
(1)
En forma individual.-
A[2]=
12
Cuanto vale A[1], A[4] …?
45
(2)
12
(3)
05
(4)
Datos
Índices
ESTRUCTURA DE DATOS ( ARREGLOS )
OPERACIONES CON ARREGLOS O VECTORES.
Las operaciones básicas con Arreglos son:
•Lectura de un arreglo
•Despliegue de datos de un arreglo
•Llenado de un arreglo
•Ordenacion de un arreglo
•Búsqueda de datos en un arreglo
ESTRUCTURA DE DATOS ( ARREGLOS )
LLENADO/LECTURA DE UN ARREGLO
Pseudocodigo:
Dame los 10 datos ?
PARA i desde 0 hasta 10 incrementa
LEE A[i].
Codigo en C o C++
printf ("Dame los 10 datos");
for (i=0; i<10; i++)
{
scanf ("%d", &valor [i]);
}
ESTRUCTURA DE DATOS ( ARREGLOS )
DESPLIEGUE DE UN ARREGLO Y OPERACIONES CON SUS
COMPONENTES
Pseudocodigo:
PARA i desde 0 hasta 10 incrementa
Inicio
DESPLIEGA “Valor”, Indice + 1, valor
SUMA los valores del arreglo
termina
Codigo en C o C++
for (i=0; i<10; i++)
{
printf ("Valor %d = %d\n", i+1, valor [i]);
suma += valor [i];
}
ESTRUCTURA DE DATOS ( ARREGLOS )
PRACTICA:
A) HACER UN PROGRAMA (ProgArreg.cpp) EN C o C++ QUE
PIDA EL PROCESO PARA N CALIFICACIONES Y LOS
DATOS DESPLEGANDO AL FINAL SU PROMEDIO.
ESTRUCTURA DE DATOS ( ARREGLOS )
ARREGLOS MULTIDIMENCIONALES:
Un vector es un array unidimensional, es decir, sólo utiliza un
índice para referenciar a cada uno de los elementos. Su
declaración será:
tipo nombre [tamaño];
Una matriz es un array multidimensional. Se definen igual que
los vectores excepto que se requiere un índice por cada
dimensión. Su sintaxis es la siguiente:
tipo nombre [tamaño 1][tamaño 2]...;
Una matriz bidimensional se podría representar gráficamente
como una tabla con filas y columnas.
ESTRUCTURA DE DATOS ( ARREGLOS )
ARREGLOS MULTIDIMENCIONALES:
Ejemplo: Una matriz de 2X3 (2 filas por 3 columnas) se inicializa en C/C++
como:
int matriz[2][3] = {
{ 20,50,30 },
{ 4,15,166 }
};
Otra manera es llenar el arreglo mediante una instrucción FOR anidada
ESTRUCTURA DE DATOS ( ARREGLOS )
/* Matriz bidimensional. */
#include <stdio.h>
#include <conio.h>
main() /* Rellenamos una matriz */
{
int x,i,numeros[3][4]; /* rellenamos la matriz */
printf("Dime los valores de matriz 3X4\n");
for (x=0;x<3;x++)
for (i=0;i<4;i++)
scanf("%d",&numeros[x][i]);
/* visualizamos la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
printf("%d",numeros[x][i]);
getch();
}
ESTRUCTURA DE DATOS ( ARREGLOS )
int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
quedarían asignados de la siguiente manera:
numeros[0][0]=1
numeros[1][0]=5
numeros[2][0]=9
numeros[0][1]=2
numeros[1][1]=6
numeros[2][1]=10
numeros[0][2]=3
numeros[1][2]=7
numeros[2][2]=11
numeros[0][3]=4
numeros[1][3]=8
numeros[2][3]=12
PRACTICA :HACER UN PROGRAMA DE UNA
MATRIZ QUE SIMULE UN TABLERO DE AJEDREZ
DE 8x8, SE LLAME EL CÓDIGO FUENTE
Matriz_tablero.cpp.
/* Programa: Matriz_tablero.cpp. Simula una matriz de 8x8 */
#include <stdio.h>
#include <conio.h>
main() {
int suma, x,i,numeros[8][8];
printf("Dime los valores de matriz 8X8\n");
for (x=0;x<8;x++)
for (i=0;i<8;i++)
scanf("%d",&numeros[x][i]);
for (x=0;x<8;x++){ // visualizamos la matriz
printf("\n");
for (i=0;i<8;i++){
printf("%d",numeros[x][i]);
}
}
printf("\n");
getch();
} // Al finalizar hacer un programa que calcule una suma de valores en casillas
Las estructuras dinámicas son las en la
ejecución varia el número de elementos
y uso de memoria a lo largo del
programa
Entre estas tenemos:
Lineales (listas ligadas o enlazadas,
pilas y colas)
No lineales (arboles y grafos o redes)
PILAS
Una pila es una colección ordenada de elementos en la cual, en
un extremo, pueden insertarse o retirarse otros elementos,
ubicados por la parte superior de la pila. Una pila permite la
inserción y eliminación de elementos, por lo que realmente es un
objeto dinámico que cambia constantemente.
Concepto
Una pila es una estructuras en donde
cada elemento es insertado y
retirado del tope de la misma, y
debido a esto el comportamiento de
un una pila se conoce como LIFO
(último en entrar, primero en salir ).
Ejemplos
Un ejemplo de pila o stack se puede
observar en el mismo procesador, es
decir, cada vez que en los programas
aparece una llamada a una función el
microprocesador guarda el estado de
ciertos registros en un segmento de
memoria conocido como Stack Segment,
mismos que serán recuperados al regreso
de la función.
Las 7 capas o pilas de una
red
según el modelo OSI
Pila en arreglo estático
Es una programación
estática de una pila en base
a un arreglo estático de
tamaño fijo
Algoritmo :
put(), poner un elemento en la pila
get(), retirar un elemento de la pila
empty(), regresa 1 (TRUE) si la pila esta vacia
size(), número de elementos en la pila
El atributo SP de la clase Stack es el apuntador de
lectura/escritura, es decir, el SP indica la posición
dentro de la pila en donde la función put() insertará el
siguiente dato, y la posición dentro de la pila de donde
la función get() leerá el siguiente dato.
•Cada vez que put() inserta un elemento el SP se
decrementa.
•Cada vez que get() retira un elemento el SP se
incrementa.
Se analiza lo que sucede con el SP (apuntador de
pila) cuando se guardan en la pila uno por uno los
caracteres 'A', 'B', 'C' y 'D'.
Llenando la pila.
SP
|
+---+---+---+---+---+
|
|
|
|
|
|
+---+---+---+---+---+
SP
|
+---+---+---+---+---+
|
|
|
|
| A |
+---+---+---+---+---+
SP
|
+---+---+---+---+---+
|
| D | C | B | A |
+---+---+---+---+---+
al principio (lista vacia)
push('A');
despues de haber agregado el primer elemento
despues de haber agregado cuatro elementos
Vaciando la pila.
SP
|
+---+---+---+---+---+
pop();
|
| D | C | B | A |
despues de
+---+---+---+---+---+
SP
|
+---+---+---+---+---+
|
| D | C | B | A |
despues de
+---+---+---+---+---+
Nota: observe que al final la lista
puntero está al final de la pila y
haber retirado un elemento
haber retirado todos los elementos
está vacia, y que dicho estado se debe a que el
no al hecho de borrar físicamente cada elemento de la pila.
Práctica
Realiza un programa de una
pila utilizando un arreglo
estático
Programación de Pila dinámica
Es igual a lo anterior con la diferencia de que una pila
enlazadada dinámicamente no tiene de forma natural el
mecanismo de acceso por índices, en ese sentido, el
programador puede crear los algoritmos necesarios para
permitir tal comportamiento.
Se crean estructuras conocidas como nodos o registros (un
registro en Lenguaje C o C++).
// declaraci¢n de estructura nodo o registro
struct nodo {
DATA_TYPE data;
nodo *next;
};
Algoritmo:
1) Al principio la lista está vacia, en ese caso el SP es igual a NULL
y, en consecuencia, el puntero next también es NULL.
SP = NULL
+------+------+
| ???? | next |--> NULL
+------+------+
2) Despues de agregar el primer elemento la situación se vería asi:
SP = asignado
1
+------+------+
| data | next |--> NULL
+------+------+
3) Despues de agregar otro elemento la situación se vería asi:
SP = asignado
2
1
+------+------+ +------+------+
| data | next |--> | data | next |--> NULL
+------+------+ +------+------+
Colas:
Una cola sencilla es una estructura en donde
cada elemento es insertado inmediatamente
después del último elemento insertado; y donde
los elementos se retiran siempre por el frente
de la misma, debido a esto el comportamiento
de un una cola se conoce como FIFO (primero
en entrar, primero en salir).
Operaciones con colas:
put() o Inserción, poner un elemento en la cola
get() o Eliminar, retirar un elemento de la cola
Búsqueda de un elemento de la cola
empty(), regresa 1 (TRUE) si la cola esta vacia
size() o recorrido del número de elementos en la cola
Cada vez que put() inserta un elemento la cola se
incrementa.
Cada vez que get() retira un elemento la cola disminuye
Ejemplo: Llenado y vaciado de una cola
Practica: Hacer un programa de Cola
basada en arreglo dinámico en C++
Bicola: cola doble
La doble cola o bicola es una variante de las
colas simples. Esta es una cola de dos
dimensiones en la que las inserciones y
eliminaciones pueden realizarse en cualquiera de
los dos extremos de la lista , pero no por la
mitad.
Bicola: cola doble
Se conocen dos variantes de las dobles colas:
La doble cola con entrada restringida (DCER) donde se permite
hacer eliminaciones por cualquiera de los extremos mientras que las
inserciones se realizan solo por el final de la cola. La doble cola
con salida restringida (DCSR) donde las inserciones se realizan por
cualquiera de los dos extremos, mientras que las eliminaciones solo
por el frente de la cola. Si bien estas estructuras están ligadas a
la computación, impresión y los sistemas de tiempo compartido,
también las podemos observar en las vías de los trenes.
Listas:
Una lista enlazada es una estructura de datos
fundamental que se utiliza para implementar otras
estructuras de datos como fue el caso de las pilas y las
colas simples y doble cola. Tiene una secuencia de
nodos, en los que se guardan campos de datos
arbitrarios y una o dos referencias, enlaces o
apuntadores al nodo anterior o posterior.
Listas simplemente ligadas
Una lista enlazada es un conjunto de elementos que contienen la posición o dirección- del siguiente. Cada elemento de una lista enlazada debe tener
al menos dos campos: uno con el valor del elemento y otro (link) que
contiene la posición del siguiente elemento o encadenamiento.
La lista enlazada básica es la lista enlazada simple la cual tiene un enlace
por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL
o a la lista vacía, si es el último nodo.
Se define una lista como una secuencia de cero o más elementos de un
mismo tipo. El formalismo encogido para representar este tipo de objeto
abstracto es:
<e1, e2 ........., en>
Cada ejemplo modela un elemento del agrupamiento. Así, e1 es el primero
de la lista; en, el último; y la lista formada por los elementos <e2,
e3,.....,en corresponde al resto de la lista inicial.
Listas doblemente ligadas
Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o
lista enlazadas de dos vías. Cada nodo tiene dos enlaces: uno apunta al
nodo anterior (o al valor NULL si es el primer nodo); y otro apunta al nodo
siguiente (o al valor NULL si es el último nodo).
Listas circulares
Esta estructura se aplica tanto a listas simples como en listas doblemente
enlazadas. La lista circular consiste en que la referencia siguiente del
ultimo nodo a punta al primero en vez de ser null, de ahí que sea circular.
Operaciones con listas
Operaciones que normalmente se ejecutan con las listas enlazadas:
1.
2.
3.
4.
5.
Recuperar información de un nodo especificado.
Encontrar un nodo nuevo que contenga información específica.
Insertar un nodo nuevo en un lugar específico de la lista.
Insertar un nuevo nodo en relación con una información particular.
Borrar un nodo existente que contenga información específica.
Práctica
Hacer un programa en C++, realice las siguientes operaciones con una lista
de nombres de clientes:
1. Agregar Nombre.
2. Listar.
3. Salir.