Estructuras de Datos Lineales

Prof. Jannelly Bello

 ESTRUCTURAS DE DATOS LINEALES
• Arreglos (unidimensionales y bidimensionales).
• Registros.
• Arreglo de registros.
• Representación de estructuras de datos en memoria.
• Cálculo y uso de memoria.
• Representación de pilas, colas y conjuntos con estructuras de
datos lineales
 ESTRUCTURAS DE DATOS LINEALES
 Definición:

 Estructuras que almacenan datos secuencialmente,

relacionados en forma lineal.
 El tipo de datos de los elementos puede ser cualquiera, pero
debe ser el mismo para todos.
 El valor contenido puede ser el mismo o diferente.
 ESTRUCTURAS DE DATOS LINEALES
 Representación Lógica:
Estudiante Calificación
Pedro Pérez 20
Mariana García 15
José Pereira 13

e1 e2 e3 e4
 ESTRUCTURAS DE DATOS LINEALES
 Ventajas:
 Se puede acceder a cualquier elemento de la estructura de
datos en tiempo constante.

 Desventajas:
 Debe establecerse un tamaño que indica el número de
elementos que pueden ser almacenados en la estructura.
 Se debe recorrer la estructura al momento de realizar
inserciones o eliminar elemento.
 ARREGLOS UNIDIMENSIONALES
 Definición.
 Son estructuras que permiten almacenar un conjunto de datos
del mismo tipo.
 Tienen un tamaño que corresponde a la cantidad de elementos
que puede almacenar.
 Son estáticos dado a que se declaran de un cierto tamaño y lo
mantienen este durante la ejecución del programa.

 Representación Lógica
 ARREGLOS UNIDIMENSIONALES
 Declaración.
tipo nombre[tamaño];

Ejemplos:

int notas[8] /* almacena ocho notas */

char nombre[21] /* almacena nombres de largo menor o igual a

20 */

int multiplos[n] /* donde n tiene un valor, declara un arreglo de

tamaño n*/
 ARREGLOS UNIDIMENSIONALES
 Inicialización :
 Inicialización en la declaración del arreglo
int n[10]={32, 27, 64, 18, 95, 24, 90, 70, 8, 3};

 Si en la declaración hay menos inicializadores que el tamaño del array,

los elementos son inicializados a cero.
int n[10]={0};

 Si en una declaración con una lista inicializadora se omite el tamaño

del arreglo el número de elementos del arreglo será el número de
elementos incluidos en la lista inicializadora.
int a1 [] = {1,2,3,4,5};

NOTA: No se puede asignar un arreglo en otro, se tiene que copiar posición a

posición.
 ARREGLOS UNIDIMENSIONALES
 Recorrido de arreglos unidimensionales.

 El índice puede ir del primero al último elemento:

for (i=0;i < n; i++)
{ proceso }

 El índice puede ir del último al primer elemento: for (i=n-1;i >= 0;i--)
{ proceso }
 ARREGLOS UNIDIMENSIONALES
 Ejemplos

int x[100],i;
for(i=0;i<100;i++)
x[i]=i;

char letras[256];
int i;
for(i=0;i<256;i++)
letras[i]=i;
 ARREGLOS UNIDIMENSIONALES
 Ejemplos

int x[10],i,suma;
for(i=0;i<10;i++)
{
printf(“Introducir un número: %d: “,i);
scanf(“%d”,&x[i]);
}

for(suma=0,i=0;i<10;i++)
suma=suma+x[i];
printf(“La suma es: “,suma);
 ARREGLOS UNIDIMENSIONALES
 Pase de arreglos a funciones
 Lenguaje C no permite el paso de un array por
valor a una función.
 un array es siempre pasado por referencia.
 Lo que se pasa es la dirección del primer
elemento del array.
 El nombre de un array es un puntero al primer
elemento.
 Sólo es posible pasar por valor elementos
individuales del array, pero no el array completo.
 ARREGLOS UNIDIMENSIONALES
 Pase de arreglos a funciones

#include <stdio.h>
void PasoValorReferencia( int *array, int valor)
{
array[5]=-8;
valor=4;
}

int main(void)
{
int array[10]={0,0,0,0,0,0,0,0,0,0};
PasoValorReferencia(array,array[3]);
printf(“Array[5] vale: %d y array[3] vale:%d\n”,array[5],array[3]);
return 0;
}

Salida:
Array[5] vale: -8 y array[3] vale: 0
 ARREGLOS UNIDIMENSIONALES
 Ejercicios
 Función que lee datos y los almacena en un arreglo

void leo_arreglo(int a[],int n)

{
for (int i=0;i < n;i++)
{
printf(“Ingrese elemento :”);
scanf (“ %d”,&a[i]);
printf(“\n”);
}
}
 ARREGLOS UNIDIMENSIONALES
 Ejercicios
 Función imprimo_arreglo, impresión de un arreglo de enteros

void imprimo_arreglo(int a[],int n)

{
for (int i=0; i <=n; i++)
{
printf(“Elemento numero %d = %d”, i+1, a[i]);
printf(“\n”);
}
}
 ARREGLOS UNIDIMENSIONALES
 Ejercicios
 Función buscar_máximo: Encuentra el máximo en un arreglo
 Función sumo_arreglo, devuelve la suma de un arreglo de
enteros
 Función promedio: devuelve el promedio de un arreglo
 ARREGLOS BIDIMENSIONALES
• Definición:

 Arreglos utilizados para representar tablas de valores que

constan de información organizada en filas y columnas.
 Para identificar un elemento particular de una tabla, se
especifican dos subíndices: el primero (por convención)
identifica la fila del elemento, y el segundo (por convención)
identifica la columna del elemento.
 ARREGLOS BIDIMENSIONALES
 Declaración.
tipo nombre[tamañoF] [tamañoC];

Ejemplos:

int notas[8] [8]; /* almacena 64 notas */

 ARREGLOS BIDIMENSIONALES
 Inicialización :
 Inicialización en la declaración:
int arreglo1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };

 Si en la declaración hay menos inicializadores

que el tamaño del array, los elementos son
inicializados a cero.
int n[10][15]={0};
 ARREGLOS BIDIMENSIONALES
 Inicialización :
 Inicialización en la declaración:
int arreglo1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };

 Si en la declaración hay menos inicializadores

que el tamaño del array, los elementos son
inicializados a cero.
int n[10][15]={0};
 ARREGLOS BIDIMENSIONALES
 Recorrido de arreglos bidimensionales.

 El índice puede ir del primero al último elemento:

for (i=0;i < n; i++)
for (j=0;j < n; j++)
{ proceso }
 ARREGLOS DE CADENAS
 Inicialización

 char cadena1[] = “primero”; //Literal de cadena

 char cadena1[] = { „p‟, „r‟, „i‟, „m‟, „e‟, „r‟, „o‟, „\0‟ }; //Caracteres individuales
constantes

 // utilizando scanf y el especificador de conversión %s.

 char cadena2[ 20 ];
 scanf( “%s”, cadena2 );
 ARREGLOS DE CADENAS
//Manipulación de arreglos de caracteres como cadenas printf( “%c “, cadena1[ i ] );
#include <stdio.h> } /* fin de for */

int main() printf( “\n” );

{
char cadena1[ 20 ]; /* reserva 20 caracteres */ return 0; /* indica terminación exitosa */
char cadena2[] = “literal de cadena”; /* reserva 18 caracteres */
} /* fin de main */
int i; /* contador */

/* lee la cadena del usuario y la introduce en el arreglo cadena1

*/
printf(“Introduce una cadena: “); Salida
Introduce una cadena: Hola amigos
scanf( “%s”, cadena1 ); /* entrada que finaliza con un espacio en
blanco */ La cadena1 es: Hola
cadena2 es: literal de cadena
/* muestra las cadenas */ La cadena1 con espacios entre caracteres es:
printf( “La cadena1 es: %s\ncadena2 es: %s\n” Hola
“La cadena1 con espacios entre caracteres es:\n”,
cadena1, cadena2 );

/* muestra los caracteres hasta que encuentra el caracter

nulo */
for ( i = 0; cadena1[ i ] != „\0‟; i++ ) {
 ESTRUCTURAS
 Colecciones de variables relacionadas bajo un nombre.
 Las estructuras pueden contener variables de diferentes tipos
de datos.
 Las estructuras generalmente se utilizan para definir registros
que van a almacenarse en archivos.
 Ejemplo:
struct empleado {
char nombre[ 20 ];
char apellido[ 20 ];
int edad;
char sexo;
double salarioPorHora;
};
 ESTRUCTURAS
 Una estructura no puede contener una instancia de sí misma.
Ejemplo:
struct empleado2 {
char nombre[ 20 ];
char apellido[ 20 ];
int edad;
char sexo;
double salarioPorHora;
struct empleado2 persona; /* ERROR */
struct empleado2 *ptrE; /* apuntador */
};
//Estructura autorreferenciada
 ESTRUCTURAS
 Declaración de variables:
 Las definiciones de estructuras no reservan espacio alguno en
memoria; en cambio, cada definición crea un nuevo tipo de dato
que se utiliza para definir variables.
 Las variables de tipo estructura se definen como las variables de
otros tipos.
 Ejemplos:
struct empleado unEmpleado, empleados[ 52 ], *ptrEmpleado;
ó

struct empleado {
char nombre[ 20 ];
char apellido[ 20 ];
int edad;
char sexo;
double salarioPorHora;
} unEmpleado, empleados[ 52 ], *ptrEmpleado;
 ESTRUCTURAS
 Las estructuras no pueden compararse por medio de
operadores == y !=.
 Debido a que el tamaño de los elementos de un tipo en
particular depende de la máquina, y debido a que las
consideraciones de alineación de almacenamiento también
dependen de la máquina, la representación de una estructura
también depende de la máquina.
 ESTRUCTURAS
 Inicialización de Estructuras:
struct carta {
char *cara;
char *palo;
};

struct carta unaCarta = { “Tres”, “Corazones” };

 Si en una lista existen menos inicializadores que miembros de la estructura,

los miembros restantes se inicializan automáticamente en 0 (o en NULL, si
el miembro es un apuntador).
 Las variables de estructuras también pueden inicializarse en instrucciones
de asignación, asignando una variable de estructura del mismo tipo, o
asignando valores a los miembros individuales de la estructura.
 ESTRUCTURAS
 Acceso a miembros de una estructura
 Se utilizan dos operadores para acceder a los miembros de estructuras: el
operador miembro de la estructura (.), también llamado operador punto, y el
operador apuntador de la estructura (->), también llamado operador flecha.

 Ejemplo: Operador Punto

printf( “%s”, unaCarta.palo ); /* despliega Corazones */

 Ejemplo: Operador Flecha

struct carta ptrCarta;
ptrCarta = &unaCarta;
printf( “%s”, ptrCarta->palo ); /* despliega Corazones */
 ESTRUCTURAS
 Uso de estructuras con funciones
 Las estructuras pueden pasarse a funciones, pasando miembros individuales
de la estructura, pasando una estructura completa o pasando un apuntador
a una estructura.
 Cuando las estructuras o los miembros individuales de la estructura pasan
a una función, pasan por valor.
 Para pasar una estructura por referencia, pase la dirección de la variable
estructura.
 Los arreglos de estructuras, como todos los demás arreglos, se pasan
automáticamente por referencia.
 ESTRUCTURAS
 Typedef
 La palabra reservada typedef permite crear alias de tipos de datos
definidos
 previamente.
 Los nombres de los tipos de estructuras con frecuencia se definen con
typedef, para crear nombres cortos.
 Ejemplo: typedef struct carta Carta;

typedef struct {
char *cara;
char *palo;
} Carta;
crea la estructura Carta sin la necesidad de una instrucción aparte typedef.