UNIVERSIDAD LATINA (UNILA)

UNIVERSIDAD LATINA (UNILA) Programación (Estructura de Datos) II.- ESTRUCTURAS DE DATOS FUNDAMENTALES LE, EI, Profesor Ramón Castro Liceaga

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): • 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 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 | +---+---+---+---+---+ | | | | | | 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; };

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 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 enlazadas 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 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 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. 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 # 08 Hacer un programa en C, C# que realice las siguientes operaciones con una lista de nombres de clientes: 1. Agregar Nombre. 2. Listar. 3. Salir.

UNIVERSIDAD LATINA (UNILA)