INTRODUCCIN A LAS

ESTRUCTURAS DE DATOS

Que son las estructuras de datos?

En programacin, una estructura de datos es una forma
de organizar un conjunto de datos elementales (un dato
elemental es la mnima informacin que se tiene en el
sistema) con el objetivo de facilitar la manipulacin de
estos datos como un todo o individualmente.
Una estructura de datos define la organizacin e
interrelacionamiento de estos, y un conjunto de
operaciones que se pueden realizar sobre l. Las
operaciones bsicas son:

Alta, adicionar un nuevo valor a la estructura.

Baja, borrar un valor de la estructura.
Bsqueda, encontrar un determinado valor en la
estructura para realizar una operacin con este
valor, en forma SECUENCIAL o BINARIO (siempre y
cuando los datos estn 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

relacin a la simplicidad y eficiencia para la
realizacin de cada operacin. De esta forma, la
eleccin de la estructura de datos apropiada para
cada problema depende de factores como la
frecuencia y el orden en que se realiza cada
operacin sobre los datos.
Tipos de estructuras de datos
Existen infinitos tipos de estructuras de datos, pero
he aqu algunos de los ms importantes:
Pilas
Grafos
Montculos
Colas y Listas
Arreglos

En este curso no abordaremos todos los tipos de

estructuras, pero abordaremos los ms importantes
como para tener un idea de la manera en que se
podra armar algn otro tipo an 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 informacin (o va
asociada a cierta informacin).
En este sentido, un nombre de variable se refiere a un
valor y un apuntador se refiere indirectamente a un

Por ejemplo: una direccin de correos, un nmero de

telfono tienen en comn que ambos indican dnde
encontrar algo.
Los apuntadores se rigen por reglas bsicas:
Un apuntador es una variable como cualquier
otra.
Una variable tipo apuntador contiene una
direccin
que apunta a otra posicin en memoria.
En dicha posicin se almacenan los datos a los
que

Declaracin de apuntadores
Los apuntadores, como cualquier otra variable, deben
se declaradas antes de ser utilizadas.
Tipo_dato * identificador
Por ejemplo:
1) int *b;
dato int.

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

indica que se tiene una variable b que apunta a un

Operadores de apuntadores
Para usar los apuntadores es necesario saber que
estn formados por dos partes: direccin y contenido:
operador & (de direccin).- indica la direccin a la
que
apunta una variable de
este
tipo.
operador * .- representa al contenido de la direccin
de
una variable de este tipo.

Operaciones aplicables a los apuntadores

Direccin: ++, --, +, Contenido: ++, -Ambos indican desplazamiento en memoria, tambin
son aplicables con arreglos, cadenas, estructuras y
para el paso de parmetros.
Ejemplo:
int i;
int *p;
p = &i;

int y = 5; int e;
int *ptr;
int *p_e;
prt = &y; p_e = &e;
*p_e = 50;

ESTRUCTURAS

Una estructura es una coleccin de uno o ms tipos de

elementos denominados miembros, cada uno de los
cuales puede ser un tipo de dato diferente.
Declaracin.- Una estructura es un tipo de dato
definido por el usuario, que se declara antes de que se
pueda utilizar. El formato de la declaracin 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
informacin en la estructura o se recupera informacin
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
continuacin, se utiliza simplemente el operador tipo
apuntador para apuntar a un miembro dado

La asignacin 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

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 funcin malloc();
o bien, tenga la direccin de una variable estructura).
ptr_est = &mejor; //ptr_est tiene la direccin (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 travs

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; //declaracin de puntero.
void main(void)
{
a=57; //inicializacin de variable
punt=&a; //asignacin de direccin al puntero.
clrscr();
printf("a = %d", a); //imprimo valor de variable
printf("\n&a = %x", &a); //imprimo direccin variable apuntada (en hexadecimal)
printf("\npunt = %x ", punt); //imprimo la direccin guardada (la de la variable
apuntada)
printf("\n*punt = %d", *punt); //imprimo el contenido de la direccin apuntada.
printf("\ntamo puntero %d", sizeof(punt));
getch();
}