le, ei, profesor ramón castro liceaga universidad latina (unila) programación (estructura de...
TRANSCRIPT
LE, EI, Profesor Ramón Castro Liceaga
UNIVERSIDAD LATINA (UNILA)
Programación (Estructura de Datos)
II.- ESTRUCTURAS DE DATOS FUNDAMENTALES
LOS DATOS A PROCESAR PUEDEN SER:
SIMPLES
Ocupan solo una casilla de memoria. (enteros, reales, caracteres, booleanos).
Ejem.- 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
Homogenea.- Son del mismo tipo (entero, reales, caracteres)
Ordemada.- Llevan un órden consecutivo a traves de un índice
Ejem.- A= 34 45 12 05 93 Datos(0) (1) (2) (3) (4) Indices
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.
Ejem.- A= 34 45 12 05 93 Datos(0) (1) (2) (3) (4) Indices
En forma individual.- A[2]= 12
Cuanto vale A[1], A[4] …?
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 (2):
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:
Ejem.- 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[0][1]=2 numeros[0][2]=3 numeros[0][3]=4
numeros[1][0]=5 numeros[1][1]=6 numeros[1][2]=7 numeros[1][3]=8
numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11 numeros[2][3]=12
PRACTICA (5):HACER UN PROGRAMA DE UNA MATRIZ QUE SIMULE UN TABLERO DE AjEDREZ DE 8x8:
/* 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 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 pilaget(), retirar un elemento de la pilaempty(), regresa 1 (TRUE) si la pila esta vaciasize(), 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 |+---+---+---+---+---+| | | | | | al principio (lista vacia)+---+---+---+---+---+ SP |+---+---+---+---+---+ push('A');| | | | | A | despues de haber agregado el primer elemento+---+---+---+---+---+ SP |+---+---+---+---+---+| | D | C | B | A | despues de haber agregado cuatro elementos+---+---+---+---+---+Vaciando la pila. SP |+---+---+---+---+---+ pop();| | D | C | B | A | despues de haber retirado un elemento+---+---+---+---+---+ SP |+---+---+---+---+---+| | D | C | B | A | despues de haber retirado todos los elementos+---+---+---+---+---+Nota: observe que al final la lista está vacia, y que dicho estado se debe a que el puntero está al final de la pila y no al hecho de borrar físicamente cada elemento de la pila.
Práctica 07.-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 comportamientode 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 colaget() o Eliminar, retirar un elemento de la colaBúsqueda de un elemento de la colaempty(), regresa 1 (TRUE) si la cola esta vaciasize() 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 Visial 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 enlazadasUna 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 enlazadas
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 circularesEsta 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 listasOperaciones que normalmente se ejecutan con las listas enlazadas:
1. Recuperar información de un nodo especificado.2. Encontrar un nodo nuevo que contenga información específica.3. Insertar un nodo nuevo en un lugar específico de la lista.4. Insertar un nuevo nodo en relación con una información particular.5. Borrar un nodo existente que contenga información específica.
Práctica # 08Hacer un programa en C, C# que realice las siguientes operaciones con una lista de nombres de clientes:
1. Agregar Nombre.2. Listar.3. Salir.