UNIVERSIDAD FERMIN TORO

FACULTAD DE INGENIERIA
DEPTO. DE PROGRAMACIN
CABUDARE. EDO. LARA

COMPUTACIN PARA INGENIEROS

PROF: GLADYS VERGEL R.
CORTE III
UNIDAD III

INTRODUCCIN
las computadoras fueron diseadas o ideadas como una herramienta
mediante la cual podemos realizar operaciones de clculo complicadas en
un lapso de mnimo tiempo. Pero la mayora de las aplicaciones de este
fantstico invento del hombre, son las de almacenamiento y acceso de
grandes cantidades de informacin.
La informacin que se procesa en la computadora es un conjunto de datos,
que pueden ser simples o estructurados. Los datos simples son aquellos que
ocupan slo una localidad de memoria, mientras que los estructurados son
un conjunto de casillas de memoria a las cuales hacemos referencia
mediante un identificador nico.
Debido a que por lo general tenemos que tratar con conjuntos de datos y no
con datos simples (enteros, reales, booleanos, etc.) que por s solos no nos
dicen nada, ni nos sirven de mucho, es necesario tratar con estructuras de
datos adecuadas a cada necesidad.
Las estructuras de datos son una coleccin de datos cuya organizacin se
caracteriza por las funciones de acceso que se usan para almacenar y
acceder a elementos individuales de datos.
En esta gua vamos a tratar el tema relacionado con las estructuras de
datos en cuanto a:

Definicin de estructura de datos

Clasificacin de las estructuras de datos
Operaciones elementales sobre las estructuras de datos
Representacin de las estructuras de datos
Clasificacin de las estructuras de datos segn su comportamiento.

Definicin de Estructura de datos:

Estructura de Datos es una coleccin de datos que se caracterizan
por su organizacin y las operaciones que se definen en ella.
Los datos de tipo estndar pueden ser organizados en diferentes
estructuras de datos: estticas y dinmicas.
Estructura de Datos estticas:
Son aquellas en las que el espacio ocupado en memoria se define en
tiempo de compilacin y no puede ser modificado durante la
ejecucin del programa.
Corresponden a este tipo los arreglos y registros
Estructuras de Datos Dinmicas:
Son aquellas en las que el espacio ocupado en memoria puede ser
modificado en tiempo de ejecucin.
Corresponden a este tipo las listas, rboles y grafos.
Estas estructuras no son soportadas en todos los lenguajes.
La eleccin de la estructura de datos idnea depender de la
naturaleza del problema a resolver y, en menor medida, del
lenguaje.
Las estructuras de datos tienen en comn que un identificador,
nombre, puede representar a mltiples datos individuales.
Clasificacin de las Estructuras de Datos.
a) Primitivas
b) No primitivas
Estructura de datos primitivas: Son aquellas que pueden ser
operadas por instrucciones a nivel de mquina, en otras palabras,
implementadas a nivel de Hardware.
Ejemplos:
Arreglos, Registros, Archivos, cadena de caracteres y conjuntos(sets).
Estructura de datos no primitivas: Son aquellas que mediante
instrucciones de lenguaje de alto nivel pueden ser implementadas haciendo
uso de las estructuras de datos primitivas.
Ejemplos:
PilaS, colas, listas lineales y rboles

Operaciones elementales sobre las estructuras de datos.

c) Creacin/destruccin
d) Extraccin
e) Almacenamiento
a) Creacin/destruccin: Para crear las estructuras de datos llamadas
variables, existen las instrucciones de declaracin. En cuanto a la
destruccin, en el momento que finaliza un programa, procedimiento
o funcin que contenga algunas de estas estructuras el espacio de
memoria previamente asignado queda destruido automticamente.
b) Extraccin: Con respecto a una variable, la manera de extraer su
valor es mediante una instruccin de asignacin.
Si la variable en cuestin es A, se tiene Y:= A
c) Almacenamiento: Tambin se realiza mediante, una instruccin de
asignacin. Si la variable en cuestin es A, s e tiene A= X * B
Representacin de las Estructuras de datos
Existen dos maneras de representar estructuras de datos en
almacenaje principal.
f) Representacin
secuencial:
Donde
los
nodos
son
almacenados en localizaciones consecutivas de almacenaje
principal.
Ejemplos: Arreglos
g) Representacin encadenada: Donde los nodos contienen
apuntadores a las direcciones de sus nodos vecinos, los cuales
no necesariamente tienen que estar fsicamente adyacentes.
5. Clasificacin de las estructuras de datos segn su
comportamiento.
a) Estructura de datos estticas
b) Estructura de datos dinmicas
c) Estructuras de datos semiestaticas
a) Estas estructuras son creadas en su totalidad antes de ser
usadas y no cambian de tamao, ni de forma desde su creacin
hasta se destruccin final, su tamao es conocido en tiempo de
compilacin.
Ejemplos:
Arreglos y Registros
B) La forma y tamao de la estructura
arbitrariamente durante su tiempo de vida.
Ejemplos
Pilas y colas

puede

variar

Arreglos o Arrays:
Un arreglo (array) es una coleccin de datos del mismo tipo, que se
almacenan en posiciones consecutivas de memoria y reciben un
nombre comn. Para referirse a un determinado elemento de un
array se deber utilizar un ndice, que especifique su posicin
relativa en el array.
Un arreglo es una coleccin finita, homognea y ordenada de
elementos.
Finita: Todo arreglo tiene un lmite; es decir, debe determinarse cul
ser el nmero mximo de elementos que podrn formar parte del
arreglo.
Homognea: Todos los elementos del arreglo deben ser del mismo
tipo.
Ordenada: Se puede determinar cul es el primer elemento, el
segundo, el tercero,. y el n-simo elmento.
Los arreglos se clasifican de acuerdo con el nmero de dimensiones
que tienen. As se tienen los:

Unidimensionales (vectores o Listas)

Bidimensionales (tablas o matrices)
Multidimensionales (tres o ms dimensiones)

Arreglos Unidimensionales:
Estn formados por un conjunto de elementos de un mismo tipo de
datos que se almacenan bajo un mismo nombre, y se diferencian por
la posicin que tiene cada elemento dentro del arreglo de datos.
Dentro del arreglo, los programas especifican el nombre de ste y el
nmero del elemento, colocndolo dentro de corchetes, como en
calificacin[3].
Al declarar un arreglo, se debe inicializar sus elementos antes de
utilizarlos.
Para declarar un arreglo tiene que indicar su tipo, un nombre nico y
la cantidad de elementos que va a contener. Por ejemplo, las
siguientes instrucciones declaran tres arreglos distintos en lenguaje
C:

Float
Int
Float

costo_partes[50];
edad_empleados[100];
precios_acciones[25];

Ejemplo de arreglo unidimensional:

Para acceder a valores especficos del arreglo, use un valor de ndice
que apunte al elemento deseado. Por ejemplo, para acceder al
primer elemento del arreglo calificaciones debe utilizar el valor de
ndice 0 (calificaciones [0]).
Los programas en C siempre indican el primer elemento de un
arreglo con 0 y el ltimo con un valor menor en una unidad al
tamao del arreglo.
Inicializacin y asignacin de valores:
Como se deca anteriormente, antes de utilizar un arreglo es
necesario inicializarlo:
Para inicializar todos los elementos de una vez, se colocan dentro de
una estructura for que va del primer elemento al ltimo que contiene
el arreglo.
Para asignar un valor a un elemento del arreglo se hace por ejemplo:
Calificaciones[0] = 100;
Cuando se usan arreglos, una operacin comn es usar una variable
ndice para acceder a los elementos de un arreglo. Suponiendo que
la variable ndice I contiene el valor 3, la siguiente instruccin asigna
el valor 400 a valores[3]:
valores[I]=400;
Partes de un arreglo:
Los componentes . Hacen referencia a los elementos que forman el
arreglo, es decir, a los valores que se almacenan en cada una de las
casillas del mismo.
Los ndices. Permiten hacer referencia a los componentes del arreglo
en forma individual, especifican cuntos elementos tendr el arreglo
y adems, de qu modo podrn accesarse esos componentes.
Operaciones con vectores:
Las operaciones que se pueden realizar con vectores durante el
proceso de resolucin de un problema son:
Lectura/ escritura
Asignacin

Actualizacin ( insercin, eliminacin, modificacin)

Recorrido (acceso secuencial)
Ordenacin
Bsqueda
Lectura y escritura de vectores:
Lectura
El proceso de lectura de un arreglo consiste en leer y asignar un
valor a cada uno de sus elementos. Normalmente se realizan con
estructuras repetitivas, aunque pueden usarse estructuras
selectivas.
Usamos los ndices para recorrer los elementos del arreglo:
For( i = 0; i< tamao; i++) {
scanf ( % f, &arre[i]) ;
}
Escritura:
Es similar al caso de lectura, slo que en vez de leer el componente
del arreglo, lo escribimos.
For( i=0; i< tamao; i++){
Printf( arreglo[%d]=%d\n, i, arreglo[i]);
}
Asignacin e Inicializacin de vectores:
Asignacin:
No es posible asignar directamente un valor a todo el arreglo; sino
que se debe asignar el valor deseado en cada componente. Con una
estructura repetitiva se puede asignar un valor a todos los
elementos del vector.
Por ejemplo:
120 (asignacin de un valor constante nico a una casilla del arre[1]
vector)

arre[1] / 4 (asignar una operacin) arre[3]

Se puede asignar un valor constante a todos los elementos del
vector:
For( i = 0 ; i< tamao; i++){
arre[i] =3;}

Inicializacin
Para inicializar con cero todos los elementos del arreglo:
For( i = 0; i< tamao i++){
arre[i] =0;
}

Acceso secuencial y Actualizacin de vectores:

Acceso Secuencial. (Recorrido)
El acceso a los elementos de un vector puede ser para leer en l o
para escribir (visualizar su contenido).
Recorrido del vector es la accin de efectuar una accin general
sobre todos los elementos de ese vector.
Actualizacin.
Incluye aadir (insertar), borrar o modificar algunos de los ya
existentes. Se debe tener en cuenta si el arreglo est o no ordenado.
Aadir datos a un vector consiste en agregar un nuevo elemento al
final del vector, siempre que haya espacio en memoria.
Los arreglos tienen cuatro propiedades bsicas:
Los elementos individuales de datos de un arreglo se denominan
elementos.
Todos los elementos deben ser del mismo tipo de dato.
Todos los elementos se almacenan en posiciones contiguas de la
memoria de la computadora y el subndice (o ndice) del primer
elemento
es
cero.
El nombre de un arreglo es un valor constante que representa la

direccin
del
primer
elemento
del
arreglo.
Para acceder a un elemento especifico del arreglo , se utiliza el
nombre de ste seguido por uno o ms ndices (donde cada uno
representa una dimensin del arreglo o array) encerrado entre
corchetes. Supongamos que tenemos un arreglo unidimensional
llamado X con un tamao de n elementos, su esquema grafico es el
siguiente:

Como puede verse en el esquema, aunque el arreglo es de n

elementos, en realidad tienen n-1 elementos porque comienzan a
enumerarse
desde
cero.
En trminos generales para definir un arreglo se especifica el tipo de
almacenamiento (atributo opcional), el tipo de datos, el identificador
y entre corchetes el tamao del arreglo. Abajo se muestra algunos
ejemplos
de
definicin
de
arreglos:
a)
b)
c)
d)

int
char
float
char

num[100];
(un
array
apellido[25];
(un
array
prom[30];
(un
array
de
contrasena[16];
(un
array

de
de
30
de

100
enteros)
25
caracteres)
coma
flotante)
16
caracteres)

La necesidad de definir arreglos

en funcin de constantes
A veces es conveniente definir el tamao de un arreglo en trminos
de una constante, en lugar de estar especificando una cantidad
entera fija. Esto se realiza por facilidad de mantenimiento. Por
ejemplo, suponga que tenemos un programa (con 350 lneas de
cdigo) donde se halle un arreglo de 20 items, y a lo largo del
programa se hace referencia unas 12 veces al arreglo, y supongamos
tambin que se necesita cambiar el tamao del arreglo. Sin usar la
constante se tendra que revisar todo el programa para localizar las
lneas de cdigo y efectuar el cambio al nuevo tamao, en cambio
con el uso de constantes slo se le cambia el tamao a la misma y el
problema est resuelto.
La definicin de un arreglo a travs de una constante se muestra en
el siguiente
ejemplo:
# include stdio.h>
# include stdlib.h>
/* Definicin de la constante */
#define tamano 20
main()
{
/* Utilizacin de la constante para definir la dimensin del arreglo */

int promedios[tamano];
/* Leer valores utilizando la variable i como contador dentro del ciclo
FOR y ++i como acumulador*/
for (i=0; i < tamano; ++i){
scanf(%d,&promedios[i]);
.....
.....
}
La utilizacin de constantes definidas garantiza que las siguientes
referencias al arreglo no sobrepasen el tamao definido para el
mismo.
El lenguaje C no comprueba que los ndices del array estn dentro
del rango definido.
Otra forma de Inicializacin de arreglos:
En ciertas circunstancias puede ser necesario darle valores iniciales a
los arreglos, para ello basta con colocar entre llaves el conjunto de
valores deseados separados por comas y en el orden requerido. A
continuacin se muestran algunos ejemplos:
a)int cant[6]={12,-3,0,15,8};
b) double DesvTipica[8]={0.23, 3.1416, -0.5, 2.16789, -56.78, 25,
0.15, -14 };
c) char meses[12]={E, F, M, A, M, J, J, A, S, O, N, D};
Para el caso del arreglo cant es como tener:
Cant[0]=12
Cant[1]= -3
Cant[2]=0
Cant[3]=15
Cant[4]=8
Cuando los elementos del arreglo no tienen asignados valores
iniciales explcitos, stos son puestos a cero, a continuacin tenemos
un ejemplo:
int edades[8]={25,13,18};
El resultado de la asignacin seria el siguiente:
Edades[0]=25;
Edades[1]=13;
Edades[2]=18;
Edades[3]=0;
Edades[4]=0;
Edades[5]=0;
Edades[6]=0;
Edades[7]=0;
Este mtodo de inicializar arreglos mediante valores constantes
despus de su definicin, es adecuado cuando el nmero de

elementos del arreglo es pequeo.

Una nota interesante en cuanto a la inicializacin de arreglos, es que
el tamao no necesita ser indicado explcitamente. Con los arreglos
numricos el tamao ser fijado igual al nmero de valores incluidos.
En cuanto a las cadenas, el tamao se fijar igual al nmero de
caracteres del string o cadena msno (el carcter nulo \0).
C puede dejar los corchetes vacos, slo cuando se asignan valores al
arreglo, tal como
int cuenta[ ] = { 15, 25, -45 , 0 , 50 };
char c[ ] = { L, u, i, s }; /* declara un array de 4 elementos */
El compilador asigna automticamente cinco elementos a cuenta.
Otros ejemplos:
a) Int porcent[ ]={8, 6, 10, -15, 23};
b) Char mes[ ]=octubre;
que vienen siendo equivalente a:
Porcent[0]=8;
porcent[1]=6;
porcent[2]=10;
porcent[3]= -15;
porcent[4]=23;
mes[0]=o;
mes[1]=c;
mes[2]=t;
mes[3]=u;
mes[4]=b;
mes[5]=r;
mes[6]=e;
mes[7]=\0
Ejemplo 1:
Elabore un programa que permita leer una lista de nmeros en un
arreglo, calcule la suma, promedio, cuadrado , cubo y desviacin
estndar de los mismos:
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<math.h>
#definetam 4
/* programa para calcular la suma, promedio, cuadrado, cubo y
desviacin
estandar de una serie de nmeros */
main()
{
double vector[tam],cuadrado, cubo;
float prom, desv,suma=0;
int i, j;

system("cls" );
printf ("PROGRAMA PARA CALCULAR \n");
printf(" PROMEDIO, SUMA, CUADRADO, CUBO Y DESV. EST.\n\n") ;
//Captura de valores y suma de los mismos
for(i = 0 ; i < tam ; ++i)
{
printf ("num [%d] = " , i) ;
scanf ("%lf" , &vector[i]) ;
suma+= vector[i] ;
}
prom = suma / tam ;
printf (" \n El promedio de los numeros es: %4.2f\n ", prom) ;
//Calculo e impresin de cuadrado, cubo y desviacin estandar
printf(" \n \n NUMERO CUADRADO CUBO DESV. EST.\n");
for( i = 0 ; i < tam ; ++i )
{
cuadrado = vector[i] * vector[i] ;
cubo = pow (vector[i], 3) ;
desv = vector [i] - prom ;
printf ("%.2lf", vector[i] ) ;
printf (" \t%.2lf", cuadrado) ;
printf (" \t%.2lf", cubo) ;
printf (" \t%.2f\n", desv) ;
}
system("pause");
return(0);
}
Nota que los valores fueron declarados de tipo double no enteros, por
el tamao de los valores que se generan en los clculos.
Ejemplo2:
El siguiente programa lee 5 valores de teclado y los guarda en un
arreglo a. Luego los escribe.
#include<stdio.h>
#include<stdlib.h>
main()
{
Int a[5],i,num;
for(i=0; i<5;i++){
printf("Digite el numero:\n");
scanf("%d",&num);
a[i]=num;
}
printf("\nEscribiendo el arreglo con los datos leidos:\n\n");
for(i=0; i<5;i++){
printf("a[%d]= %d\n\n",i,a[i]);
}
system("pause");

return 0;
}
Ejemplo 3:
El siguiente programa, pide 5 nmeros y calcula los cubos de ellos,
los cuales son guardados en un arreglo y son desplegados.
#include stdio.h>
#include stdlib.h>
#include math.h>
main()
{
int i;
double a[5], num;
for (i=0; i<5; i++)
{
printf("\n Digite numero:");
scanf("%lf", &num);
a[i]=num;
}
printf("_________________________________________\n");
printf("Los cubos de los nmeros ledos son:\n");
for (i=0; i<5; i++){
a[i]=pow(a[i],3);
printf("%.0lf\n",a[i]);
}
printf("\n");
system("pause");
return 0;
}
El lenguaje C no realiza comprobacin de contornos en los arreglos.
En el caso de que sobrepase el final durante una operacin de
asignacin, entonces se asignarn valores a otra variable o a un trozo
del cdigo, esto es, si se dimensiona un arreglo de tamao N, se
puede referenciar el arreglo por encima de N sin provocar ningn
mensaje de error en tiempo de compilacin o ejecucin, incluso
aunque probablemente se provoque el fallo del programa. Como
programador se es responsable de asegurar que todos los arreglos
sean lo suficientemente grandes para guardar lo que pondr en ellos
el programa.
Nota 1: C permite arreglos con ms de una dimensin, el formato
general es:
Tipo de dato nombre_arreglo[ tam1 ][ tam2 ] [ tamN];
Arreglos Bidimensionales: (Matrices):

Los arreglos bidimensionales nos permiten guardar los elementos de

una matriz. Estructura de datos formada por una coleccin finita de
elementos homogneos, ordenados cada uno de ellos en dos
dimensiones y referenciados con un nombre comn. El acceso a un
elemento del arreglo bidimensional se realiza mediante el nombre del
arreglo (identificador) y un par de ndices que indican la posicin del
elemento.
Una matriz es un arreglo de dos dimensiones, y para especificar
cualquier elemento, debemos hacer referencia a dos ndices (que
representan la posicin como fila
y columna). Aunque no se
justificar aqu, es conveniente mencionar que la representacin
matricial es puramente conceptual y con el nico fin de facilitar al
programador el manejo de los elementos, ya que la computadora
almacena los datos en una forma totalmente diferente.
DECLARACION DE UN ARRAYS BIDIMENSIONAL
Para declarar arreglos bidimensionales se debe tener en cuenta la
siguiente instruccin:
Sintaxis:
Tipo nombre arreglo [filas][columnas] ;
Tipo: tipo de dato de los elementos del arreglo (int, float, etc.)
Nombre arreglo: identificador que representa la coleccin de
elementos.
Filas: constante entera positiva que representa la cantidad de filas.
Columnas: constante entera positiva que representa la cantidad de
columnas.
Ejemplo2:
Float

matriz1[4 ][3];

Podemos trabajar con cada uno de los elementos de la matriz:

REPRESENTACIN GRAFICA DE UN ARRAY BIDIMENCIONAL

OPERACIONES EN ARREGLOS BIDIMENCIONALES

LECTURA
Este proceso consiste en leer un dato de un arreglo y asignar un valor
a cada uno de sus componentes. La lectura se realiza de la siguiente
manera:
para i desde 1 hasta N haz x<--arreglo[i]
ESCRITURA Consiste en asignarle un valor a cada elemento del
arreglo. La escritura se realiza de la siguiente manera: para i desde 1
hasta N haz arreglo[i]=x
ASIGNACION No es posible asignar directamente un valor a todo el
arreglo, por lo que se realiza de la manera siguiente: para i desde 1
hasta N haz arreglo[i]=algn_valor
ACTUALIZACION Dentro de esta operacin se encuentran las
operaciones de eliminar, insertar y modificar datos. Para realizar este
tipo de operaciones se debe tomar en cuenta si el arreglo est o no
ordenado. Para arreglos ordenados los algoritmos de insercin, borrado
y modificacin son los siguientes:
1.- Insertar. Si i< mensaje(arreglo contrario caso En arreglo[i]=valor
i=i+1 entonces.
2.- Borrar. Si N>=1 entonces inicio i=1 encontrado=falso mientras
i<=n y encontrado=falso Inicio si arreglo[i]=valor_a_borrar entonces
inicio
Encontrado=verdadero N=N-1 para k desde i hasta N haz arreglo[k]arreglo[k-1] fin en caso contrario i=i+1 fin Fin Si encontrado=falso

entonces mensaje (valor no encontrado)

3.- Modificar. Si N>=1 entonces Inicio i=1 encontrado<--falso
mientras i<=N y encontrado=false haz inicio Si arreglo[i]=valor
entonces arreglo[i]= valor_nuevo encontrado=verdadero En caso
contrario i=i+1 fin Fin

EJEMPLO:
El siguiente programa realiza la lectura de una matriz de 7 renglones y 15
columnas (de una matriz de orden [7x15]) rengln por rengln).
Lenguaje C:
#include <stdio.h>
#include<conio.h>
#define fil 7
#define col 15
main ()
{
int i, j;
Int x [fil ][col];

for (i=0; i<fil ; i++)

for(j=0; j<col ; j ++)
{
printf (INTRODUCE EL ELEMENTO A (%d, %d) , I, j);
scanf (%d, &x [i] [j]);
}
}

Para inicializar una matriz todas sus posiciones en cero.

For( i=0; i<fil; i++){
For(j=0; j<col; j++){
Matriz[i][j]=0;
}
}
Para cargar una matriz con informacin o valores:
For( i=0; i<fil; i++){
For(J=0; J<col; j++){
Printf(Matriz[%d][%d]=\n, i,j);
Scanf(%d, & matriz[i][j]);
}
}
Para imprimir una matriz en pantalla:
For( i=0; i<fil; i++){

For(J=0; J<col; j++){

Printf(%d, matriz[i][j]);
}
Printf(\t\n);
}
CONCLUSIONES
1. Los arreglos bidimensionales nos permiten trabajar con varios elementos del mismo tipo
simultneamente y para acceder a estos se hace por medio sus ndices.
2. Este tipo de estructura de programacin estructurada hace ms fcil la ejecucin, la
comprensin y adems se tiene una mejor presentacin de un programa.
3. Los arreglos son muy importantes a la hora de trabajar con elementos relacionados a travs de
filas y columnas