Capitulo V Estructuras de Datos Estaticas: Arreglos Unidimensionales (Vectores)

Universidad Salesiana de Bolivia Ingeniería de Sistemas
CAPITULO V
ESTRUCTURAS DE DATOS ESTATICAS
Un array es un identificador que referencia un conjunto de datos del mismo tipo.
Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y
utilizar uno u otro con sólo cambiar el índice que lo referencia. El índice será un valor
entero y positivo. En C los arrays comienzan por la posición 0.
Arreglos Unidimensionales (Vectores)

Los arreglos unidimensionales son arreglos de una sola dimensión, y para operar con
cualquiera de sus elementos se debe escribir el nombre del arreglo seguido de UN
subíndice entre corchetes [ ].
Representación gráfica:
………..
Primer Segundo Ultimo

Elemento Elemento elemento
Los arreglos están compuestos elementos, donde cada elemento, a su vez, está
formado por los índices y datos, los índices hacen referencia a la cantidad de
elementos del arreglo y a la posición en la cual se localizan, los datos se refieren a la
información que se almacena en cada una de las casillas, por lo tanto para hacer
referencia a un dato de un arreglo se utiliza el nombre del arreglo y el índice del
elemento.
Ejemplo
Por ejemplo podría ser un vector denominado NOTA:
NOTA[0] NOTA[1] NOTA[2] NOTA[3] …………………… NOTA[k] ………. NOTA[30]
75 68 51 49 …………………. 68 ……. 100

0 1 2 3 ……………… k ……. n
Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar a

cada uno de los elementos.
Programación I 66 Dossier
Declaración
En Diagrama de Flujo
En Lenguaje C
tipo_datos nombre_vector[tamaño]
Donde:
declara el tipo de los elementos del arreglo

tipo_datos :
(array)
indica el nombre de la variable que representa

nombre_vector :
al vector
indica cuantos elementos podrá almacenar el

tamaño :
vector
Ejemplos
1. int edad[20]; /* vector edad almacenará 20 valores enteros */

2. float precios[50]; /* vector precios almacenará 50 valores reales */
3. long fono[10]; /* vector fono almacenará 10 valores entero largos */
4. char nomb[41]; /* vector nomb almacenará 40 caracteres */
También, podemos inicializar (asignarle valores) un vector en el momento de

declararlo. Si lo hacemos así no es necesario indicar el tamaño. Su sintaxis es:
tipo nombre [] = { valor 1, valor 2, ……};
Ejemplos:
1. int vector[]={1, 2, 3, 4, 5, 6, 7, 8};

2. char vector[]="programador";
3. char vector[]={'p', 'r', 'o', 'g', 'r', 'a', 'm', 'a', 'd', 'o', 'r'};
Una particularidad con los vectores de tipo char (cadena de caracteres), es que
deberemos indicar en que elemento se encuentra el fin de la cadena mediante el
caracter nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los
que insertemos este caracter al final de la cadena.
Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo

de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4],
debemos asignar el caracter nulo a vector[5]. Es muy sencillo: vector[5]='\0'; .
Operaciones con Vectores
Asignación de un Valor
En Diagrama de Flujo En Lenguaje C
A[4] Å 17 A[4] = 17
A= 81 57 22 -3 17
0 1 2 3 4 5
Modificación de un Valor
A[0] Å A[3] A[0] = A[3]
A= -3 57 22 -3 17
0 1 2 3 4 5
Lectura de un Valor
scanf(“%d”, &A[5]);
A[5]
cin << A[5];
A= -3 57 22 -3 17 1
0 1 2 3 4 5
Escritura de un Valor
printf(“%d”, A[2]);
A[2]
cout >> A[2];
Mostrar
A= -3 57 22 -3 17 1
0 1 2 3 4 5 22
Lectura de elementos del Vector
/* Procedimiento de lectura de datos,

LeerV(NÈ, A [ ]Ç) en este caso, el vector ejemplo
agrupa al conjunto de valores enteros
*/
I Å 0, N – 1, +1 void LeerV(int n, int a[ ])
{
int i;
A[I]
for(i = 0; i < n; i ++)
{
//Mensaje para el usuario
cout<<”A[”<<i<<”] = ”;
Fin_ LeerV //Use scanf (“%d”, &a[i]);
cin >>a[i];
}
}
Listado de elementos del Vector
/* Procedimiento de impresión de
MostV(NÈ, A [ ]È) valores almacenados en un vector,
en este caso, el vector ejemplo
agrupa un conjunto de valores
I Å 0, N – 1, +1 enteros */
void MostV(int n, int a[ ])
{
A[I] int i;
//Mensaje para el usuario
cout<<”Los elementos de V son:\n”
for (i = 0; i < n; i ++)
{
Fin_ MostV //Mensaje para el usuario

cout<<”A[”<<i<<”] = ”;
//Use printf (“%d, ”, a[i]); ó
cout<<a[i]<<”, ”;
Ejemplo
}
/* Programa que almacena los N primeros numeros naturales en un vector */
}
#include <stdio.h>
#include <conio.h>
#define MAX 100 /*definicion de la constante MAX que indica el tamaño
máximo del vector*/
/***************** P R O TO T I P O S *******************/
int LeerDim(void); /* lee la dimension del vector */

void MostrarV(int num[MAX], int n); /* muestra el vector */
/******* D E F I N I C I O N D E S U B P R O G R A M A S *******/
int LeerDim(void)
{
int n;
do
{
scanf("%d",&n);
if (n<=0)
{
printf("\n\n E R R O R ! ! !");
printf("\n\n Debe introducir un número entero mayor que
cero");
printf("\n\n Intente de nuevo...");
}
else
{
if (n > MAX)
{
printf("\n\n Debe introducir un número entero menor que
%d", MAX);
}
}
}while (n<=0 || n > MAX);
return(n);
}
/******************************************************/
void MostrarV(int num[MAX], int n)
{
int i;
for(i = 0; i < n; i = i+1)

{
printf(" %d ", num[i]);
}
}
/************************ M A I N ************************/
int main(void)
{
int t[MAX]; /* declaracion del vector t de enteros de tamaño MAX */
int a, i;
clrscr();
printf("Cuantos elementos desea generar?? ");
a=LeerDim();
for(i=0; i<a;i=i+1)
{
t[i] = i;
}
printf("\n\nLos primeros %d numeros naturales son:\n\n", a);
MostrarV(t, a);
printf("\n\n");
getch();
return(0);
}
Arreglos Bidimensionales (Matrices)

Hasta ahora, todos los arreglos que se han considerado han sido unidimensionales de
modo que bastaba un sólo índice para especificar un elemento deseado. Cuando la
información se acomoda de manera natural en una disposición rectangular o cuadrada,
es decir en una tabla de valores, puede ser ventajoso almacenarla en un arreglo
bidimensional, también llamado "matriz".
Fila 0
Fila 1
Fila 2
Fila 3
Fila 4
Columna 5
Columna 4
Columna 3
Columna 2
Columna 1
Columna 0
Una matriz puede considerarse como un vector de vectores. Es, por consiguiente, un
conjunto de elementos, todos del mismo tipo, en el cual el orden de los componentes
es significativo y se necesitan dos índices para especificar uno de sus elementos, un
subíndice de renglón o fila y un subíndice de columna.
Un array bidimensional, también denominado matriz o tabla, tiene dos dimensiones

(una dimensión por cada subíndice) y necesita un valor para cada subíndice y poder
identificar a cada uno de sus elementos. El primer subíndice se refiere a la fila de la
matriz, mientras que el segundo subíndice se refiere a la columna.
Sea B una matriz de N filas y M columnas:
0 ……..
1 B[i][j]
………
2 ……..
…. ……..
B= ……..
i ……….
….. ………
N-1 ……
0 1 2 3 4 5 ….. j …. M-1
el elemento B[i, j] es aquel que ocupa la i-ésima fila y la j-ésima columna.
Donde i = 0..N o bien 0 <= i <= N - 1
j = 0..M o bien 0 <= j <= M - 1
El arreglo B se dice que tiene N por M elementos ya que existen M elementos en cada
fila y N elementos en cada columna.
Declaración
En Diagrama de Flujo
nomb_const = valor
nomb_matriz = MATRIZ[nomb_cons, nomb_const] DE tipo_valor
PROCESOS
fin
En Lenguaje C
tipo_datos nombre_matriz[tamaño_filas][tamaño_columnas]
Donde:
declara el tipo de los elementos del arreglo

tipo_datos :
(array)
indica el nombre de la variable que representa a

nombre_matriz :
la matriz
tamaño_filas : indica la cantidad máxima de filas de la matriz
indica la cantidad máxima de columnas de la

tamaño_columas :
matriz
Ejemplos
1. int notas[6][50];
2. float ventas[10][12];
3. int miss[10][10];
Operaciones con Matrices
Lectura de elementos de la Matriz
/* Procedimiento de lectura de datos

en una matriz, en el ejemplo que
LeerM(fÈ, cÈ, A [ ][ ]Ç)
seguimos sus datos son enteros */
void LeerM (int f, int c, int a[ ][ ])

I Å 0, f – 1, +1 {
int i, j;
J Å 0, c - 1, +1 cout<<”\nLos elementos de la
matriz son:\n”;
for (i = 0; i <= f - 1; i ++)

A[I][J]
for (j = 0; j <= c - 1; j ++)
cout<<”M[”<< i <<”] [“<< j

<<”]= ”;
// Use scanf(“%d”, &a[ i ][ j ]);

// ó
cin>> mat[ i ] [ j ];
Fin_ LeerM
}
Listado de elementos de la Matriz
/* Procedimiento que imprime los

elementos que tiene una matriz, en
MostrarM(fÈ, cÈ, A [ ][ ]È) nuestro ejemplo, la matriz de números
enteros imprime sus valores */
void MostrarM (int f, int c, int a[ ][ ])

{
I Å 0, f – 1, +1
int i, j;
for(i = 0; i <= f - 1; i ++)

{
J Å 0, c - 1, +1
for(j = 0; j <= c – 1; j ++)
{
cout<<mat [ i ] [ j ] << “ “;
}
A[I][J] cout <<”\n”; //Dando un enter
}
}
Fin_ MostrarM
Ejemplo
/* Programa que lee y muestra los elementos de una matriz */

#include <stdio.h>
#include <conio.h>
#define MAX 10 /* definicion de la constante MAX que indica el tamanio
máximo del vector */
/***************** P R O TO T I P O S *******************/
int LeerDim(void); /* lee una de las dimensiones de la matriz */

void LeerM(int n, int m, int mat[MAX][MAX]); /* carga la matriz */
void MostrarM(int n, int m, int num[MAX][MAX]); /* muestra la matriz */
void Pausa(void);
/******* D E F I N I C I O N D E S U B P R O G R A M A S *******/
int LeerDim(void)
{
int n;
do
{
scanf("%d",&n);
if (n<=0)
{
printf("\n\n Debe introducir un numero entero mayor que cero");
}
else
{
if (n > MAX)
{
printf("\n\n Debe introducir un numero entero menor que %d",
MAX);
}
}
}while (n<=0 || n > MAX);
return(n);
}
/******************************************************/
void MostrarM(int n, int m, int num[MAX][MAX])
{
int i, j;
for(i = 0; i < n; i = i+1)

{
for(j = 0; j < m; j++)
{
printf("%5d", num[i][j]);
}
printf("\n");
}
}
/*********************************************************/
void LeerM(int n, int m, int mat[MAX][MAX])
{
int i,j;
for(i = 0; i < n; i = i+1)

{
for(j = 0; j < m; j++)
{
printf("\n\nT[%d][%d] = ", i, j);
scanf("%d", &mat[i][j]);
}
}
}
/*****************************************************/
void Pausa(void)
{
printf("Presione cualquier tecla para continuar...");
getch();
}
/************************ M A I N ************************/
int main(void)
{
int t[MAX][MAX]; /* declaracion de la matriz t de tamaño MAX*MAX */
int a, b;
clrscr();
printf("Ingrese la cantidad de filas de la matriz...");
a=LeerDim();
printf("Ingrese la cantidad de columnas de la matriz...");
b=LeerDim();
printf("\n\n Introduzca los elementos de la matriz...");
LeerM(a, b, t);
printf("\n\nLos elementos de la matriz son:\n");

MostrarM(a, b, t);
printf("\n\n");
Pausa();
return(0);
}
Si al declarar una matriz también queremos inicializarla, habrá que tener en cuenta el
orden en el que los valores son asignados a los elementos de la matriz. Veamos
algunos ejemplos:
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

0 1 2 3
0 1 2 3 4
numeros = 1 5 6 7 8
2 9 10 11 12
También se pueden inicializar cadenas de texto:
char dias[7][10]={"lunes","martes","miércoles","jueves","viernes",
"sábado","domingo"};
Para referirnos a cada palabra bastaría con el primer índice:
printf("%s",dias[i]);
CAPÍTULO VI
MÉTODOS DE BÚSQUEDA
Introducción
La búsqueda es una operación que tiene por objeto la localización de un elemento
dentro de la estructura de datos. A menudo un programador estará trabajando con
grandes cantidades de datos almacenados en arreglos y pudiera resultar necesario
determinar si un arreglo contiene un valor que coincide con algún valor clave o
buscado.
Siendo el array de una dimensión o lista una estructura de acceso directo y a su vez
de acceso secuencial, encontramos dos técnicas que utilizan estos dos métodos de
acceso, para encontrar elementos dentro de un array: búsqueda lineal y búsqueda
binaria.
Método de Búsqueda Secuencial

La búsqueda secuencial es la técnica más simple para buscar un elemento en un
arreglo. Consiste en recorrer el arreglo elemento a elemento e ir comparando con el
valor buscado (clave). Se empieza con la primera casilla del arreglo y se observa una
casilla tras otra hasta que se encuentra el elemento buscado o se han visto todas las
casillas. El resultado de la búsqueda es un solo valor, y será la posición del elemento
buscado o cero. Dado que el arreglo no está en ningún orden en particular, existe la
misma probabilidad de que el valor se encuentra ya sea en el primer elemento, como
en el último. Por lo tanto, en promedio, el programa tendrá que comparar el valor
buscado con la mitad de los elementos del arreglo.
El método de búsqueda lineal funciona bien con arreglos pequeños o para arreglos no
ordenados. Si el arreglo está ordenado, se puede utilizar la técnica de alta velocidad
de búsqueda binaria, donde se reduce sucesivamente la operación eliminando
repetidas veces la mitad de la lista restante.
El método expresado en pseudocódigo sería:
ind Å 0
sw Å 0
mientras (sw = 0) Λ (ind < N) hacer
si arreglo[ind] = valor_buscado
entonces
sw Å 1
si_no
ind Å ind + 1
fin_si
fin_mientras
si sw = 1
entonces
Mostrar “Encontrado”
si_no
Mostrar “No encontrado”
fin_si
Método de Búsqueda Binaria

La búsqueda binaria es el método más eficiente para encontrar elementos en un
arreglo ordenado. El proceso comienza comparando el elemento central del arreglo
con el valor buscado. Si ambos coinciden finaliza la búsqueda. Si no ocurre así, el
elemento buscado será mayor o menor en sentido estricto que el central del arreglo.
Si el elemento buscado es mayor se procede a hacer búsqueda binaria en el subarray
superior, si el elemento buscado es menor que el contenido de la casilla central, se
debe cambiar el segmento a considerar al segmento que está a la izquierda de tal sitio
central.
El método expresado en pseudocódigo sería:
sw Å 0
primero Å 0
ultimo Å N - 1
mientras (primero <= ultimo) Λ (sw = 0) hacer
mitad Å (primero + ultimo)/2
si arreglo[mitad] = valor_buscado
entonces
sw Å 1
si_no
si arreglo[mitad] > valor_buscado
entonces
ultimo Å mitad - 1
si_no
primero Å mitad + 1
fin_si
fin_si
fin_mientras
si sw = 1
entonces
si_no
fin_si
Método de Búsqueda Mediante Transformaciones de

Claves (Hashing)
La idea principal de este método consiste en aplicar una función que traduce el valor
del elemento buscado en un rango de direcciones relativas. Una desventaja importante
de este método es que puede ocasionar colisiones.
El pseudocódigo correspondiente al método sería:
funcion hash (valor_buscado)

inicio
hash Å valor_buscado mod numero_primo
fin
inicio Å hash (valor)

il Å inicio
sw Å 0
repetir
si arreglo[il] = valor
entonces
sw Å 1
si_no
il Å (il +1) mod N
fin_si
hasta (sw = 1) V (il = inicio)
si sw = 1
entonces
si_no
fin_si
CAPÍTULO VII
METODOS DE ORDENACIÓN
Introducción
Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la
clasificación u ordenación de los mismos. Se considera ordenar al proceso de
reorganizar un conjunto dado de objetos en una secuencia determinada. Cuando se
analiza un método de ordenación, hay que determinar cuántas comparaciones e
intercambios se realizan para el caso más favorable, para el caso medio y para el caso
más desfavorable.
La colocación en orden de una lista de valores se llama Ordenación. Por ejemplo, se

podría disponer una lista de valores numéricos en orden ascendente o descendente, o
bien una lista de nombres en orden alfabético. La localización de un elemento de una
lista se llama búsqueda.
Tal operación se puede hacer de manera más eficiente después de que la lista ha sido
ordenada. Existen varios métodos para ordenamiento, clasificados en tres formas:
• Intercambio
• Selección
• Inserción.
En cada familia se distinguen dos versiones: un método simple y directo, fácil de

comprender pero de escasa eficiencia respecto al tiempo de ejecución, y un método
rápido, más sofisticado en su ejecución por la complejidad de las operaciones a
realizar, pero mucho más eficiente en cuanto a tiempo de ejecución. En general, para
arreglos con pocos elementos, los métodos directos son más eficientes (menor tiempo
de ejecución) mientras que para grandes cantidades de datos se deben emplear los
llamados métodos rápidos.
Método de Intercambio o de la Burbuja

El método de intercambio se basa en comparar los elementos del arreglo e
intercambiarlos si su posición actual o inicial es contraria inversa a la deseada. Aunque
no es muy eficiente para ordenar listas grandes, es fácil de entender y muy adecuado
para ordenar una pequeña lista de unos 100 elementos o menos.
Una pasada por la ordenación de burbujeo consiste en un recorrido completo a través

del arreglo, en el que se comparan los contenidos de las casillas adyacentes, y se
cambian si no están en orden. La ordenación por burbujeo completa consiste en una
serie de pasadas ("burbujeo") que termina con una en la que ya no se hacen cambios
porque todo está en orden.
Ejemplo:
Supóngase que están almacenados cuatro números en un arreglo con casillas de

memoria de x[0] a x[3]. Se desea disponer esos números en orden creciente. La
primera pasada de la ordenación por burbujeo haría lo siguiente:
• Comparar el contenido de x[0] con el de x[1]; si x[0] contiene el mayor de los

números, se intercambian sus contenidos.
• Comparar el contenido de x[1] con el de x[2]; e intercambiarlos si fuera
necesario.
• Comparar el contenido de x[2] con el de x[3]; e intercambiarlos si fuera
necesario.
Al final de la primera pasada, el mayor de los números estará en x[3].
El método expresado en pseudocódigo es:
Desde I Å 1 hasta n - 1 hacer
Desde J Å 0 hasta n - 2 hacer
Si elemento [J] > elemento [J + 1]
Entonces
aux Å elemento [J]
elemento [J] Å elemento [J + 1]
elemento [J + 1] Å aux
Fin_si
Fin_desde
Fin_desde
Método de Ordenación por Inserción

El fundamento de este método consiste en insertar los elementos no ordenados del
arreglo en subarreglos del mismo que ya estén ordenados. Por ser utilizado
generalmente por los jugadores de cartas se lo conoce también por el nombre de
método de la baraja.
Dependiendo del método elegido para encontrar la posición de inserción tendremos

distintas versiones del método de inserción.
Ejemplo
aux Å elemento[I]
kÅI-1
sw Å 0
Mientras (sw = 0) Λ (k >= 0) hacer
Si aux < elemento [k]
Entonces
elemento [k + 1] Å elemento [k]
kÅk–1
Si_no
sw Å 1
Fin_si
Fin_mientras
elemento [k+1] Å aux
Fin_desde
Método de Ordenación por Selección

Los métodos de ordenación por selección se basan en dos principios básicos:
• Seleccionar el elemento más pequeño (o más grande) del arreglo.

• Colocarlo en la posición más baja (o más alta) del arreglo.
A diferencia del método de la burbuja, en este método el elemento más pequeño (o

más grande) es el que se coloca en la posición final que le corresponde.
Ejemplo
aux Å elemento [I]
kÅI
Desde J Å I + 1 hasta n - 1 hacer
Si elemento [J] < aux
Entonces
aux Å elemento [J]
kÅj
Fin_si
Fin_desde
elemento [k] Å elemento [I]
elemento [I] Å aux
Fin_desde
Método de Ordenación Rápida (Quicksort)

Si bien el método de la burbuja era considerado como el peor método de ordenación
simple o menos eficiente, el método Quicksort basa su estrategia en la idea intuitiva
de que es más fácil ordenar una gran estructura de datos subdividiéndolas en otras
más pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si
dividimos el array a ordenar en dos subarrays de forma que los elementos del
subarray inferior sean más pequeños que los del subarray superior, y aplicamos el
método reiteradamente, al final tendremos el array inicial totalmente ordenado.
Método de Ordenación Shell

El método burbuja acerca cada elemento a la posición que le corresponde paso a paso,
como se acaba de explicar. Sin embargo, su tiempo de ejecución para vectores
pequeños puede ser aceptable, no así para los arreglos con muchos elementos; para
eso surge este método que agiliza la ordenación en grandes vectores, y se denomina
Shell en honor a su inventor.
Este método consiste en comparar, no elementos consecutivos como lo hacía el

método de la burbuja, sino los que están separados por un intervalo grande, de modo
que cada uno se acerca al lugar que le corresponde de forma más rápida.
Inicialmente, ese intervalo o salto corresponde con la mitad de la longitud del vector.
Posteriormente, cuando ya todos los elementos separados por esa distancia están
ordenados, se divide ese intervalo por dos y se opera de igual forma hasta que,
finalmente, el salto se reduzca a 1. Entonces, el proceso de ordenación funciona
exactamente como el de la burbuja y realiza la comparación de los elementos
adyacentes.
Ejemplo
Los elementos a utilizar en el algoritmo son los siguientes:
d: es una variable que indica la distancia de comparación.

sw: comprueba la ordenación a distancia d.
1 = desordenado a distancia d.
0 = ordenado a distancia d.
Y el pseudocódigo correspondiente es el siguiente:
d=n
Mientras d<>1
d = |d/2|
sw = 1
Mientras sw = 1
sw = 0
Para (i = 1, i <= n – d, i++)
Si (v[j] > v[i + d])
aux = v[i]
v[i] = v[i + d]
v[i + d] = aux
sw = 1
FinSi
FinPara
FinMientras
FinMientras
CAPITULO VIII
ESTRUCTURAS
Concepto de estructura
Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas
bajo un mismo nombre para que su manejo sea más sencillo.
Declaración
struct tipo_estructura
{
tipo_campo1 nombre_campo1;
};
Donde:
tipo_estructura es el nombre del nuevo tipo de dato que hemos creado
tipo_campo y nombre_campo son las variables que forman parte de la estructura.
Ejemplos
1. struct reglib
{
char titlib[40];
char autlib[30];
int npag;
int aned;
};
2. struct regalu
{
char nomb[30];
char ape[30];
int edad;
char fecnac[8];
int ci;
};
Definición de variables de tipo registro

Para definir variables del tipo que acabamos de crear lo podemos hacer de varias
maneras, aunque las dos más utilizadas son estas:
Una forma de definir la estructura:
/******** DEFINICION DEL TIPO TRABAJADOR *****/
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
};
/*** DECLARACION DE LAS VARIABLES DE TIPO TRABAJADOR ***/
struct trabajador fijo, temporal;
Otra forma:
/****DEFINICION DEL TIPO TRABAJADOR Y DECLARACION DE LAS VARIABLES

DE TIPO TRABAJADOR ********/
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
} fijo, temporal;
En el primer caso declaramos la estructura, y luego declaramos las variables. En el

segundo las declaramos al mismo tiempo que la estructura. El problema del segundo
método es que no podremos declarar más variables de este tipo a lo largo del
programa. Para poder declarar una variable de tipo estructura, la estructura tiene que
estar declarada previamente. Se debe declarar antes de la función main.
Ejemplos
1. struct reglib
{
char titlib[40];
char autlib[30];
int npag;
int aned;
} libro;
2. struct regalu
{
char nomb[30];
char ap[30];
int edad;
char fecnac[8];
int ci;
};
struct alumno;
Manejo de las estructuras

Para acceder a los elementos individuales de la estructura se utiliza el operador .
(operador punto) de la siguiente forma:
nomb_registro.nomb_campo
Ejemplos
1. Sea la variable libro de tipo reglib del ejemplo anterior, podemos asignarle valores
a algunos de sus campos de la siguiente forma:
libro.npag = 200;
libro.aned = 1998;
fgets(libro.titlib, 40, stdin);
fgets(libro.autlib, 30, stdin);
2. Sea la variable alumno de tipo regal del ejemplo anterior, podemos asignarle
valores a algunos de sus campos de la siguiente forma:
alumno.edad = 18;
alumno.ci = 5887456;
fgets(alumno.nomb, 30, stdin);
fgets(alumno.ap, 30, stdin);
3. Si queremos mostrar en la pantalla el valor de uno de los campos:

printf(“%d”, libro.npag);
4. Ejemplo completo de manejo de estructuras :
/**************************************************************
Programa que pemite la introduccion de un registro y luego muestra
su contenido por pantalla
**************************************************************/
#include <stdio.h>
#include <conio.h>
#include "lineas.c"
/*************** DEFINICION DEL REGISTRO *****************/
struct reglib
{
char titlib[50];
char autlib[40];
char edlib[30];
int aned;
int npag;
}libro;
/****************** PROTOTIPOS ********************/
char Menu(void);
void LeerR(void);
void MostrarR(void);
/*************** DEFINICION DE SUBPROGRAMAS **************/
char Menu(void)
{
char resp;
clrscr();
Margen(29, 5, 50, 7, 2);
Wxy(33,6, "MENU PRINCIPAL");
Margen(20, 8, 60, 15, 2);
Wxy(28, 9, "[L]eer el registro");
Wxy(28, 11, "[M]ostrar el registro");
Wxy(28,13, "[S]alir");
Margen(25, 16, 55, 18, 1);
Wxy(30, 17, "Digite su opcion... ");
gotoxy(51,17);
resp=(char)toupper(getch());
return resp;
}
/**********************************************************/
void LeerR(void)
{
int i;
clrscr();
Margen(28, 1, 52, 3, 2);
Wxy(30, 2, "LECTURA DEL REGISTRO");
/* TITULO */
Wxy(1, 5,"Titulo del Libro : ");
fgets(libro.titlib, 50, stdin);
fflush(stdin);
for (i = strlen(libro.titlib)-1; i && libro.titlib[1] < ''; i--)

libro.titlib[i] = 0;
/* AUTOR */
Wxy(1, 7, "Autor del Libro : ");
fgets(libro.autlib, 40, stdin);
fflush(stdin);
for (i = strlen(libro.autlib)-1; i && libro.autlib[1] < ''; i--)

libro.autlib[i] = 0;
/* EDITORIAL */
Wxy(1, 9,"Editorial del Libro : ");
fgets(libro.edlib, 30, stdin);
fflush(stdin);
for (i = strlen(libro.edlib)-1; i && libro.edlib[1] < ''; i--)

libro.edlib[i] = 0;
/* ANIO DE EDICION */
Wxy(1, 11,"Anio de Edicion : ");
scanf("%d", &libro.aned);
/* CANTIDAD DE PAGINAS */
Wxy(1, 13,"Cantidad de Paginas : ");
scanf("%d", &libro.npag);
}
/**********************************************************/
void MostrarR(void)
{
clrscr();
Margen(1, 3, 79, 20, 2);
Wxy(2, 9,"TITULO");
gotoxy(24, 9);
printf(": %s", libro.titlib);
Wxy(2, 11, "AUTOR");

gotoxy(24, 11);
printf(": %s", libro.autlib);
Wxy(2, 13, "EDITORIAL");

gotoxy(24,13);
printf(": %s", libro.edlib);
Wxy(2, 15, "ANIO DE EDICION");

gotoxy(24,15);
printf(": %d", libro.aned);
Wxy(2, 17,"CANTIDAD DE PAGINAS");

gotoxy(24, 17);
printf(": %d", libro.npag);
Mensaje();
/******************* MAIN ********************/
int main(void)
{
char opcion = '0';
do
{
opcion = Menu();
switch(opcion)
{
case 'L' : /* Lectura del registro */
LeerR();
break;
case 'M' : /* Mostrar el registro */
MostrarR();
break;
} /*fin switch*/
}while(opcion != 'S');
return 0;
}

Capitulo V Estructuras de Datos Estaticas: Arreglos Unidimensionales (Vectores)

Cargado por

Copyright:

Formatos disponibles

Capitulo V Estructuras de Datos Estaticas: Arreglos Unidimensionales (Vectores)

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Capitulo V Estructuras de Datos Estaticas: Arreglos Unidimensionales (Vectores)

Cargado por

Copyright:

Formatos disponibles

Universidad Salesiana de Bolivia Ingeniería de Sistemas

Arreglos Unidimensionales (Vectores)

Primer Segundo Ultimo

Por ejemplo podría ser un vector denominado NOTA:

NOTA[0] NOTA[1] NOTA[2] NOTA[3] …………………… NOTA[k] ………. NOTA[30]

75 68 51 49 …………………. 68 ……. 100

Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar a

declara el tipo de los elementos del arreglo

indica el nombre de la variable que representa

indica cuantos elementos podrá almacenar el

1. int edad[20]; /* vector edad almacenará 20 valores enteros */

También, podemos inicializar (asignarle valores) un vector en el momento de

tipo nombre [] = { valor 1, valor 2, ……};

1. int vector[]={1, 2, 3, 4, 5, 6, 7, 8};

Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo

Operaciones con Vectores

En Diagrama de Flujo En Lenguaje C

En Diagrama de Flujo En Lenguaje C

A[0] Å A[3] A[0] = A[3]

En Diagrama de Flujo En Lenguaje C

En Diagrama de Flujo En Lenguaje C

Lectura de elementos del Vector

En Diagrama de Flujo En Lenguaje C

/* Procedimiento de lectura de datos,

Listado de elementos del Vector

En Diagrama de Flujo En Lenguaje C

Fin_ MostV //Mensaje para el usuario

int LeerDim(void); /* lee la dimension del vector */

}while (n<=0 || n > MAX);

for(i = 0; i < n; i = i+1)

Arreglos Bidimensionales (Matrices)

Un array bidimensional, también denominado matriz o tabla, tiene dos dimensiones

Sea B una matriz de N filas y M columnas:

el elemento B[i, j] es aquel que ocupa la i-ésima fila y la j-ésima columna.

Donde i = 0..N o bien 0 <= i <= N - 1

j = 0..M o bien 0 <= j <= M - 1

nomb_matriz = MATRIZ[nomb_cons, nomb_const] DE tipo_valor

declara el tipo de los elementos del arreglo

indica el nombre de la variable que representa a

tamaño_filas : indica la cantidad máxima de filas de la matriz

indica la cantidad máxima de columnas de la

Operaciones con Matrices

Lectura de elementos de la Matriz

En Diagrama de Flujo En Lenguaje C

/* Procedimiento de lectura de datos

void LeerM (int f, int c, int a[ ][ ])

for (i = 0; i <= f - 1; i ++)

cout<<”M[”<< i <<”] [“<< j

// Use scanf(“%d”, &a[ i ][ j ]);

Listado de elementos de la Matriz

En Diagrama de Flujo En Lenguaje C

/* Procedimiento que imprime los

void MostrarM (int f, int c, int a[ ][ ])

for(i = 0; i <= f - 1; i ++)

/* Programa que lee y muestra los elementos de una matriz */

int LeerDim(void); /* lee una de las dimensiones de la matriz */

}while (n<=0 || n > MAX);

for(i = 0; i < n; i = i+1)

Una forma de definir la estructura:

/**** DEFINICION DEL TIPO TRABAJADOR */

/* DECLARACION DE LAS VARIABLES DE TIPO TRABAJADOR */

/* DEFINICION DEL REGISTRO ***/

/ PROTOTIPOS **/

/* DEFINICION DE SUBPROGRAMAS /