INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS

¿Que son las estructuras de datos?

En programación, una estructura de datos es una forma de organizar un conjunto de datos elementales (un dato elemental es la mínima información que se tiene en el sistema) con el objetivo de facilitar la manipulación de estos datos como un todo o individualmente.

Una estructura de datos define la organización e interrelacionamiento de estos, y un conjunto de operaciones que se pueden realizar sobre él. Las operaciones básicas son:

• Alta, adicionar un nuevo valor a la estructura. • Baja, borrar un valor de la estructura. • Búsqueda, encontrar un determinado valor en la

estructura para realizar una operación con este valor, en forma SECUENCIAL o BINARIO (siempre y cuando los datos estén ordenados).

Otras operaciones que se pueden realizar son:• Ordenamiento, de los elementos pertenecientes a

la estructura. • Apareo, dadas dos estructuras originar una nueva

ordenada y que contenga a las apareadas.

Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia para la realización de cada operación. De esta forma, la elección de la estructura de datos apropiada para cada problema depende de factores como la frecuencia y el orden en que se realiza cada operación sobre los datos.

Tipos de estructuras de datosExisten infinitos tipos de estructuras de datos, pero he aquí algunos de los más importantes:

• Pilas • Grafos • Montículos• Colas y Listas • Arreglos •

Registros• Árboles • Tablas Hash

En este curso no abordaremos todos los tipos de

estructuras, pero abordaremos los más importantes

como para tener un idea de la manera en que se

podría armar algún otro tipo aún mas complicado

Apuntadores

Una Variable puntero es una variable que contiene direcciones de otras variables.

Todas las variables vistas hasta antes de este momento contienen valores de datos, por el contrario las variables tipo apuntador contienen valores que son direcciones de memoria donde se almacenan datos.

Un apuntador, son variables que contienen direcciones de memoria (localidades o posiciones), donde se encuentra almacenada cierta información (o va asociada a cierta información).

En este sentido, un nombre de variable se refiere a un valor y un apuntador se refiere indirectamente a un valor.

Por ejemplo: una dirección de correos, un número de teléfono tienen en común que ambos indican dónde encontrar algo.

Los apuntadores se rigen por reglas básicas:

• Un apuntador es una variable como cualquier otra. • Una variable tipo apuntador contiene una dirección que apunta a otra posición en memoria. • En dicha posición se almacenan los datos a los que apunta el apuntador. • Un apuntador apunta a una variable de memoria.

Declaración de apuntadores

Los apuntadores, como cualquier otra variable, deben se declaradas antes de ser utilizadas.

Tipo_dato * identificador

Por ejemplo:

1) int *b; indica que se tiene una variable b que apunta a un dato int.

2) float *c; 3) char *p;

Operadores de apuntadores

Para usar los apuntadores es necesario saber que están formados por dos partes: dirección y contenido:

operador & (de dirección).- indica la dirección a la que apunta una variable de este tipo. operador * .- representa al contenido de la dirección de una variable de este tipo.

Operaciones aplicables a los apuntadores

Dirección: ++, --, +, - Contenido: ++, --

Ambos indican desplazamiento en memoria, también son aplicables con arreglos, cadenas, estructuras y para el paso de parámetros.

Ejemplo: int i; int y = 5; int e; int *p; int *ptr; int *p_e; p = &i; prt = &y; p_e = &e;

*p_e = 50;

ESTRUCTURAS

Una estructura es una colección de uno o más tipos de elementos denominados miembros, cada uno de los cuales puede ser un tipo de dato diferente.

Declaración.- Una estructura es un tipo de dato definido por el usuario, que se declara antes de que se pueda utilizar. El formato de la declaración es: struct <nombre de la estructura> { <tipo de dato miembro1> <nombre miembro1>;

<tipo de dato miembro2> <nombre miembro2>;

• • • <tipo de dato miembron> <nombre miembron>;

};

Por ejemplo: Declarar una estructura persona: struct persona { char nombre [30]; int edad; float altura; float peso; };

Acceso a estructuras

Cuando se accede a una estructura, o bien se almacena información en la estructura o se recupera información de la estructura. Se puede acceder a los miembros de una estructura de una de estas dos formas:

1) Utilizando el operador punto (•) 2) Utilizando el operador apuntador ->

Acceso a una estructura de datos mediante el operador tipo apuntador

El operador tipo apuntador ->, sirve para acceder a los datos de la estructura a partir de un apuntador. Para utilizar este operador se debe definir primero una variable tipo apuntador para apuntar a la estructura. A continuación, se utiliza simplemente el operador tipo apuntador para apuntar a un miembro dado

La asignación de datos a estructuras utilizando el operador tipo apuntador tiene el formato:

<apuntador estructura> -> <nombre miembro> = dato;

Por ejemplo, una estructura estudiante:

struct estudiante { char nombre[35]; int mat_est; float cal; };

Se puede definir ptr_est como apuntador a la estructura

struct estudiante *ptr_est; struct estudiante mejor;

A los miembros de la estructura estudiante se pueden asignar datos como sigue (siempre y cuando la estructura ya tenga creado su espacio de almacenamiento, por ejemplo, con la función malloc(); o bien, tenga la dirección de una variable estructura).

ptr_est = &mejor; //ptr_est tiene la dirección (apunta) mejor

strcpy(prt_est -> nombre, “Juan Perez”);

ptr_est -> mat_est = 1234;

ptr_est -> cal = 8.9;

/* Programa que suma un valor a una variable a través de un apuntador */ #include <stdio.h>#include <conio.h>void main() {

int a, *p; a=5; p=&a; *p+=7; //*p=*p+7 printf("\nEl valor final de a es: %d", a);

}

#include <stdio.h>#include <conio.h>int a;int *punt; //declaración de puntero.void main(void) { a=57; //inicialización de variable punt=&a; //asignación de dirección al puntero. clrscr(); printf("a = %d", a); //imprimo valor de variable printf("\n&a = %x", &a); //imprimo dirección variable apuntada (en hexadecimal)

printf("\npunt = %x ", punt); //imprimo la dirección guardada (la de la variable apuntada) printf("\n*punt = %d", *punt); //imprimo el contenido de la dirección apuntada. printf("\ntamño puntero %d", sizeof(punt)); getch(); }