UNIDAD 4.

- ARREGLOS BIDIMENSIONALES
DEFINICIN DE MATRIZ
Una matriz es un arreglo bidimensional, por lo tanto es un dato de tipo estructurado esttico,
con la particularidad de que al ser un arreglo todos los datos son de la misma naturaleza (son
homogneos), y adems presenta la caracterstica de que sus elementos se almacenan en la
memoria RAM; por lo que al apagar la computadora o cuando termina el programa
stos se pierden.
Subndices: indican la posicin de un elemento, en Lenguaje C, pueden comenzar en
el valor 0 (cero).
En este caso se posee:
Subndice para las filas: que le llamaremos i.
Subndice para las columnas: que le llamaremos j.
Por ejemplo:
A[i][j] representa el elemento de la i-sima fila y j-sima columna de la matriz A.
A[2][3] representa el elemento de la fila 2 y de la columna 3 de la matriz A.
Al ser una matriz un conjunto de datos, tanto su
lectura como su impresin se realizan con estructuras de iteracin anidadas cuyos cortes de
control sern uno para las filas y uno para las columnas.
LECTURA E IMPRESIN POR FILAS
Para leer una matriz por filas el primer ciclo de repeticin debe ser para las filas, y el
segundo e interno ser para las columnas.
#include<stdio.h>
#include<conio.c>
main (void)
{
int a[100][100];
clrscr ();
int i,j,n,m;
printf(ingrese la cantidad de filas: );
scanf(%d,&m);
printf(ingrese la cantidad de columnas: );
scanf(%d,&n);
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
printf("%d",a[i][j]);
}
}
getch();
}
LECTURA E IMPRESIN POR COLUMNAS
Para leer una matriz por columnas el primer ciclo de repeticin debe ser para las
columnas, y el segundo e interno ser para las filas.
MTODO DE BSQUEDA.
Dada una matriz A de orden MxN y un elemento k, el mtodo de bsqueda
trata de determinar si dicho elemento se encuentra en la matriz o no. Para este fin se utiliza
una variable bandera que se inicializar con el valor 0 (cero) y cambiar si el valor k
buscado se encuentra dentro de los elementos de la matriz.

Si la matriz contiene elementos repetidos cuando se cambia el valor de la bandera

tambin se debe mostrar la posicin donde se encuentra cada elemento igual a k.
Si la matriz contiene NO contiene elementos repetidos cuando se cambia el valor de
la bandera tambin se puede mostrar la posicin donde se encuentra el elemento encontrado,
o se puede mostrarlo al final previamente guardado en una variable.
PROGRAMA PARA BUSCAR EL VALOR K DENTRO DE LOS ELEMENTOS DE LA MATRIZ SIN
ELEMENTOS REPETIDOS
#include<stdio.h>
#include<conio.h>
main (void)
{
clrscr ();
int i,j,n,m,b,k,pos;
int a[100][100];
printf(ingrese la cantidad de filas: );
scanf(%d,&m);
printf(ingrese la cantidad de columnas: );
scanf(%d,&n);
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
printf(Ingrese el elemento a[%d][%d] = ,i,j);
scanf("%d",&a[i][j]);
}
}
printf(\n\n);
printf(ingrese el valor k que desea buscar: );
scanf(%d,&k); b=0
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
if (a[i][j]==k)
{
b=1;
pos=1;
}
}
} if (
b==1)
{
printf(\n\n El valor %d se encuentra en la posicin %d,k,pos);
}
else
{
printf(\n\n El valor %d NO se encuentra en la matriz,k);
}
getch();
}
ARREGLOS MULTIDIMENSIONALES
DEFINICIN
Un arreglo multidimensional, es un dato de tipo estructurado esttico, con la particularidad de
que al ser un arreglo todos los datos son de la misma naturaleza (son homogneos), y

adems presenta la caracterstica de que sus elementos se almacenan en la memoria RAM; por lo que al
apagar la computadora o cuando termina el programa stos se pierden.
LECTURA E IMPRESIN
Para leer un arreglo multidimensional se realiza un ciclo de repeticin por cada dimensin que
posea.

PROGRAMA PARA LECTURA E IMPRESIN DE UN ARREGLO TRIDIMENSIONAL

#include <stdio.h>
#include <conio.c>
main (void)
{
int i,j,k,n,m,p;
int a[100][100][100];
printf("hola");
printf("ingrese la cantidad de filas: ");
scanf("%d",&m);
printf("ingrese la cantidad de columnas: ");
scanf("%d",&n);
printf("ingrese la profundidad: ");
scanf("%d",&p);
for(k=0;k<p;k++)
{
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j][k]);
printf("%d",a[i][j][k]);
}
}
}
getch();
}

REGISTROS
DEFINICIN
Un registro, en programacin, es un tipo de dato estructurado esttico, donde sus elementos pueden ser
de distinta naturaleza, es decir que son heterogneos; los mismos se denominan campos; y pueden ser, o
bien datos elementales (entero, real, carcter,...), o bien otras estructuras de datos.
Los registros son llamados tambin estructuras en lenguaje C, y cada uno de sus elementos se denominan
miembros.
LECTURA E IMPRESIN
Para ingresar o mostrar los datos de un registro, es necesario hacerlo campo por campo.
En el siguiente ejemplo se ingresan y muestran los campos cdigo, descripcin y precio de un
artculo.

PROGRAMA PARA LECTURA E IMPRESIN DE LOS ELEMENTOS DE UN REGISTRO

#include <stdio.h>
#include <conio.c>
#include <string.h>
struct registro
{
int codigo;
char descri[30];
float precio;

};
main (void)
{
registro reg;
printf("Ingrese los datos del registro\n\n");
printf("Codigo: ");
scanf("%d",&reg.codigo);
printf("Descripcion: ");
scanf("%s",reg.descri);
printf("Precio: ");
scanf("%f",&reg.precio);
printf("\n\nLOS DATOS INGRESADOS SON:\n\n");
printf("Codigo: %d",reg.codigo);
printf("\nDescripcion: ");
puts(reg.descri);
printf("Precio: %.2f",reg.precio);
getch();
}
REGISTROS JERARQUIZADOS
Un registro jerarquizado tambin denominado en lenguaje C como estructura anidada, es un registro
en el cul por lo menos uno de sus campos es a su vez un registro.
Ejemplo:
Al registro del artculo que tena los campos cdigo, descripcin y precio le agregamos el campo
fecha de vencimiento; el cual a su vez es un registro que posee los campos da, mes y ao.

PROGRAMA PARA LECTURA E IMPRESIN DE LOS ELEMENTOS DE UN REGISTRO JERARQUIZADO

#include <stdio.h>
#include <conio.h>
#include <string.h>
struct fecha
{
int dia,mes,anio;
};
struct registro
{
int codigo;
char descri[30];
float precio;
fecha fec;
};
main (void)
{
registro reg;
printf("Ingrese los datos del registro\n\n");
printf("Codigo: ");
scanf("%d",&reg.codigo);
printf("Descripcion: ");
scanf("%s",reg.descri);
printf("Precio: ");
scanf("%f",&reg.precio);
printf("\n\nFecha de Vto: \n");
printf("Dia: ");
scanf("%d",&reg.fec.dia);
printf("Mes: ");

scanf("%d",&reg.fec.mes);
printf("Ao: ");
scanf("%d",&reg.fec.anio);
printf("\n\nLOS DATOS INGRESADOS SON:\n\n");
printf("Codigo: %d",reg.codigo);
printf("\nDescripcion: ");
puts(reg.descri);
printf("Precio: %f",reg.precio);
printf("\n\nFecha de Vto: \n");
printf("Dia: %d",reg.fec.dia);
printf("\nMes: %d",reg.fec.mes);
printf("\nAo: %d",reg.fec.anio);
getch();

ARRAY DE REGISTROS
Un array de registros es un arreglo (vector, matriz, arreglo multidimensional) cuyos elementos son registros.
Este tipo de estructura surge para poder conservar en memoria los valores que se ingresan de todos los
registros, caso contrario se tiene en memoria los valores slo del ltimo registro ingresado.

Ejemplo:
Ingresar y mostrar un array (vector) de registros de 2 elementos; cuyos registros tendrn la siguiente
configuracin: cdigo, descripcin y precio.
PROGRAMA PARA INGRESAR Y MOSTRAR UN ARRAY DE REGISTROS
#include <stdio.h>
#include <conio.c>
#include <string.h>
struct registro
{
int codigo;
char descri[30];
float precio;
};
main (void)
{
registro v[2];
int i;
for (i=0;i<2;i++)
{
clrscr();
printf("Ingrese los datos del registro %d\n\n",i);
printf("Codigo: ");
scanf("%d",&v[i].codigo);
printf("Descripcion: ");
scanf("%s",v[i].descri);
printf("Precio: ");
scanf("%f",&v[i].precio);
}
for (i=0;i<2;i++)
{
clrscr();
printf("\n\nLOS DATOS INGRESADOS SON REGISTRO %d:\n\n",i);

printf("Codigo: %d",v[i].codigo);
printf("\nDescripcion: ");
puts(v[i].descri);
printf("Precio: %.2f",v[i].precio);
getch();
}
}
REGISTROS DE ARRAY
Un registro de array es un registro en el cual por lo menos uno de sus campos es un arreglo.
Ejemplo:
Un registro que posee los campos:
Legajo
Notas (es un vector de 5 elementos)

PROGRAMA PARA INGRESAR Y MOSTRAR UN REGISTRO DE ARRAY

#include <stdio.h>
#include <conio.c>
#include <string.h>
struct registro
{
int legajo;
int notas[5];
};
main (void)
{
registro reg;
int j;
printf("Ingrese los datos del registro\n\n");
printf("Legajo: ");
scanf("%d",&reg.legajo);
for (j=0;j<5;j++)
{
printf("Nota %d: ",j);
scanf("%d",&reg.notas[j]);
}
printf("\n\nLos datos ingresados del registro\n\n");
printf("Legajo: %d",reg.legajo);
for (j=0;j<5;j++)
{
printf("\nNota %d: %d",j,reg.notas[j]);
}
getch();
}

CONCEPTOS DE DATOS ESTRUCTURADOS

DEFINICIN DE DATO ESTRUCTURADO
Se llama estructura de datos o tipo de dato estructurado a los tipos de datos construidos a partir de otros
tipos de datos. Es un conjunto de datos.

Pueden realizarse diferentes clasificaciones. Atendiendo al tipo de los datos que la componen.
Desde el punto de vista de la gestin de memoria las estructuras de datos, se clasifican en:
Estticas: si poseen un nmero fijo de elementos. Los ejemplos ms tpicos son los arrays y
registros. Su mayor desventaja es la necesidad de tener que definir el nmero mximo de elementos
que podr tener la estructura. Su mayor ventaja es la rapidez de acceso a cada elemento individual
de la estructura. Estas estructuras reservan la gestionan la memoria en tiempo de compilacin del
programa.
Dinmicas: si el nmero de elementos que contienen puede variar durante la ejecucin del
programa. Su principal inconveniente es la lentitud en el acceso, ya que normalmente se realiza de
forma secuencial. La ventaja es sin embargo importante, la posibilidad de aumentar o disminuir en
tiempo de ejecucin el nmero de elementos que componen la estructura. La gestin de memoria se
realiza en tiempo de ejecucin del programa.

ARREGLOS UNIDIMENSIONALES
Un array es una estructura de datos formada por una cantidad fija de datos de un mismo tipo.
El array es una estructura de datos esttica y homognea. Al definir un array en un programa se
especifica su tamao (nmero de elementos que la constituyen) con lo cual el compilador del
lenguaje reserva memoria para el array. Dentro de la memoria, el array se almacena de forma
contigua.
Un arreglo es un tipo de dato estructurado, en el cual todos los elementos son de la misma
naturaleza, es decir que son homogneos, adems presenta la caracterstica de que sus
elementos se almacenan en memoria RAM; por lo que al apagar la computadora estos datos se
pierden.

TRATAMIENTO DE ARCHIVOS: ALTAS, BAJA LGICA, BAJA FSICA, MODIFICACIONES,

CONSULTAS, LISTADOS
ALTA
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct registro
{
int legajo,edad;
char apeynom[30];
float sueldo;
bool borrado;
};
main (void)
{
registro reg;
FILE *arch;
int n,i;
/*Alta*/
printf("Ingrese la cantidad de empleados: ");
scanf("%d",&n);
arch=fopen("empleados.dat","w+b");
for (i=0;i<n;i++)
{
printf("\n\nIngrese los datos del registro\n\n");
printf("Legajo : ");
scanf("%d",&reg.legajo);
_flushall();

printf("Apellido y Nombre: ");

gets(reg.apeynom);
printf("Sueldo : ");
scanf("%f",&reg.sueldo);
printf("Edad : ");
scanf("%d",&reg.edad);
reg.borrado=false;
fwrite(&reg,sizeof(registro),1,arch);
}
fclose(arch);
}
BAJA FSICA
#include <stdio.h>
#include <conio.h>
struct registro
{
int legajo,edad;
char apeynom[30];
float sueldo;
bool borrado;
};
main (void)
{
registro reg;
FILE *arch,*auxiliar;
int b,leg; //b=0 no lo encontro b=1 encontro
/*Baja Fisica*/
arch=fopen("empleados.dat","r+b");
auxiliar=fopen("auxiliar.dat","wb");
printf("Ingrese un numero de legajo a dar de BAJA: ");
scanf("%d",&leg);
fread(&reg,sizeof(registro),1,arch);
b=0;
while (!feof(arch))
{
if (reg.legajo!=leg)
fwrite(&reg,sizeof(registro),1,auxiliar);
else
b=1;
fread(&reg,sizeof(registro),1,arch);
}
if (b==1)
{
printf("\n\nRegistro dado de baja");
}
fclose(arch);
fclose(auxiliar);
remove("empleados.dat");
rename("auxiliar.dat","empleados.dat");
}

BAJA LGICA
/* Dado el archivo empleados.dat, ingresar un legajo de un empleado y realizar
la baja lgica de este registro en el archivo.*/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct registro
{
int legajo,edad;
char apeynom[30];
float sueldo;
bool borrado;
};
main (void)
{
registro reg;
FILE *arch;
bool band;
int leg;
system("CLS");
printf("Ingrese el legajo a dar de baja= ");
scanf("%d",&leg);
arch=fopen("empleados.dat","r+b");
fread(&reg,sizeof(registro),1,arch);
band=false;
while(feof(arch)==0 && band==false)
{
if (reg.legajo==leg && reg.borrado==false)
{
reg.borrado=true;
fseek(arch,- sizeof(registro),SEEK_CUR);
fwrite(&reg,sizeof(registro),1,arch);
printf("Registro dado de baja\n\n");
getch();
band=true;
}
else
{
fread(&reg,sizeof(registro),1,arch);
}
}
rewind(arch);
fread(&reg,sizeof(registro),1,arch);
while(!feof(arch))
{
if (reg.borrado==false)
{
printf("Legajo: %d\n",reg.legajo);

printf("Apellido y Nombre: %s\n",reg.apeynom);

printf("Sueldo: %.2f\n",reg.sueldo);
printf("Edad: %d\n\n",reg.edad);
}
fread(&reg,sizeof(registro),1,arch);
}
fclose(arch);
getch();
}