ESTRUCTURAS ANIDADAS PRESENTACION

UNIVERSIDAD ANDINA
“NÉSTOR CÁCERES VELÁSQUEZ”
FACULTAD DE INGENIERÍA Y CIENCIAS
PURAS
CAP INGENIERÍA CIVIL
TEMA : Estructuras anidadas
Presentado Por :
Apaza Coaquira Edward Jhonatan
Choque Istalla Pablo Roberto
Galarza Gonzales Anthony Jhosep
Tipula Yanapa Carlos Gabriel
Calcina Aza Joel

Estructura
program circulo
Real :: r, area
write (*,*) 'Escribe el radio r:'
read (*,*) r
area = 3.14159*r*r
write (*,*) 'Area = ', area
stop
end
Este programa lee un
número real r y muestra
el área del círculo con
radio r.

UNIONES
ES SIMILAR A LA DE "ESTRUCTURA", LA
DIFERENCIA ENTRE LAS DOS ES QUE EN UNA
ESTRUCTURA, LOS MIEMBROS OCUPAN
DIFERENTES ÁREAS DE LA MEMORIA, PERO
EN UNA UNIÓN, LOS MIEMBROS OCUPAN LA
MISMA ÁREA DE MEMORIA.

Uniones
Una unión es una estructura en la que se comparte una región de memoria para
almacenar datos de tipos distintos.
El tamaño de la unión es igual al del tipo de datos más grande.
union prueba{
int a;
float b;
char c;
};
main(){
prueba x;
x.a = 5;
printf("a= %d, b= %f, c= %cn",x.a,x.b,x.c);
x.b = 5.0;
x.c = '5';
getch();
}
b
prueba
c
a
a= 5, b= 0.000000, c= ♣
a= 1084227584, b=
5.000000, c=
a= 1084227637, b=
5.000025, c= 5

Estructuras y Uniones
En la creación de soluciones para algunos problemas surge la
necesidad de agrupar datos de diferente tipo o de manejar datos
que serían muy difícil de describir en los tipos de datos primitivos,
esta es la situación en la que debemos aprovecharnos de las
características que hacen al lenguaje C especial, o sea el uso de
estructuras, uniones y punteros .
Programación en C/Estructuras y Uniones

Una estructura puede estar dentro de otra estructura
a esto se le conoce como anidamiento o estructuras
anidadas. Ya que se trabajan con datos en
estructuras si definimos un tipo de dato en una
estructura y necesitamos definir ese dato dentro de
otra estructura solamente se llama el dato de la
estructura anterior.
Estructuras Anidadas

Estructuras Anidados
if (x > 0) then
if (x >= y) then
write(*,*) 'x es positivo y x >= y'
else
write(*,*) 'x es positivo pero, x < y'
endif
elseif (x < 0) then
write(*,*) 'x es negativo'
else
write(*,*) 'x es cero'
endif

Estructuras anidadas
Las estructuras pueden contener a
otras estructuras como
componentes.
Una estructura que tiene
componentes de tipo estructura se
llama estructura anidada.

Ejemplo
Ejemplo de estructuras anidadas
struct fecha{
int dia,mes,anyo;
};
struct persona{
char nombre[20];
char apellido[20];
fecha nacimiento;
int edad;
int sexo;
char CURP[19];
char telefono[20];
};
nombre apellido nacimiento edad sexo CURP telefono
dia mes año

Desplegar una fecha
void despliegaFecha(fecha f){
printf("%d de ",f.dia);
switch(f.mes){
case 1:printf("ene");break;
case 2:printf("feb");break;
case 3:printf("mar");break;
case 4:printf("abr");break;
case 5:printf("may");break;
case 6:printf("jun");break;
case 7:printf("jul");break;
case 8:printf("ago");break;
case 9:printf("sep");break;
case 10:printf("oct");break;
case 11:printf("nov");break;
case 12:printf("dic");break;
}
printf(" de %dn",f.anyo);
}

Acceso a estructuras
anidadas
Se puede acceder a los campos de una estructura
anidada mediante el operador “.”. Por ejemplo:
persona per,*per2;
per.nacimiento.dia = 5;
per.nacimiento.mes = 7;
per.nacimiento.anyo = 1998;
per2->nacimiento.dia = 1;
per2->nacimiento.mes = 8;
per2->nacimiento.anyo = 2005;
Note que el campo anidado se accede mediante el operador “.” y el no anidado
mediante “->”.

dia mes año
calle colonia ciudad estado pais numero
nombreapellidos
direccionDatos personales
nombre apellidos calle colonia ciudad estado pais num cp
fecha
direccionStruct
nombreStruct
Gráfico de las estructuras

depto trabajo
posicion
empleado
dirnom
nombredireccion
depto trabajo
trabajo salario numDepto fechaIngreso
dia mes año
estudiante
direccionDatos personales
nombredireccion carrera promedio creditos

Ejemplos
Despliega nombre y teléfono de los pacientes con la máxima gravedad.
for(i = 0;i<50;i++)
if(pas[i].condicion==5)
printf(“Nombre: %s, telefono: %sn”,
pas[i].nombre,pas[i].telefono);
Calcula porcentaje de pacientes hombres y mujeres
suma = 0;sumaF = 0;
for(i = 0;i<50;i++)
if(pas[i].sexo==‘H’)
sumaH++;
else
sumaF++;
printf(“% de Hombres= %.2fn”,sumaH/50*100);
printf(“% de Mujeres= %.2fn”,sumaF/50*100);

 Nada impide que los miembros de una estructura
sean a su vez tipos de datos estructurados, es
decir:
 Otras estructuras
 Arreglos
 Estas estructuras se denominan anidadas.
 Incuso pueden ser estructuras recursivas.

Ejemplo
struct fecha{
int dia,mes,anyo;
};
struct persona{
char nombre[20],apellido[20];
fecha nacimiento;
char sexo;
union{
struct {
float peso,estatura;
}varon;
struct {
int medidas[3];
}hembra;
};
};

struct punto{
double x;
double y;
};
struct circunferencia{
struct punto centro;
double radio;
};

double perimetro(struct circunferencia c){
return 2*PI*c.radio;
}
double area(struct circunferencia c){
return PI*c.radio*c.radio;
}

double distancia(struct punto p1, struct punto p2){
return sqrt( pow(p2.x+p1.x,2) + pow(p2.y+p1.y,2));
}
int intersectan(struct circunferencia c1,struct
circunferencia c2){
double dist = distancia(c1.centro, c2.centro);
printf("%.2f vs %.2fn",dist,c1.radio+c2.radio);
return (dist < c1.radio+c2.radio);
}

int main(){
struct circunferencia ca;
struct circunferencia cb;
ca.centro.x=0;
ca.centro.y=0;
ca.radio = 1;
cb.centro.x=1.9;
cb.centro.y=0;
cb.radio = 1;
printf("p:%.2f, a:%.2f, int?
%sn",perimetro(ca),area(ca),
(intersectan(ca,cb)?"Si":"No"));
}

Arbol binario:
Estructura formada
Con nodos de los
cuales cuelgan cero,
uno o dos hijos, lo
Cuales son a su vez
arboles binarios

Valor nulo  0
Puntero nulo  NULL

ESTRUCTURAS ANIDADAS
struct arbol_binario{
int valor;
struct arbol_binario hijo_derecho;
struct arbol_binario hijo_izquierdo;
};
struct arbol_binario{
int valor;
struct arbol_binario* hijo_derecho;
struct arbol_binario* hijo_izquierdo;
};

ESTRUCTURAS ANIDADAS
void mostrar(struct arbol_binario
arbol){
printf("%d ",arbol.valor);
if(arbol.hijo_derecho!=0)
mostrar(*arbol.hijo_derecho);
if(arbol.hijo_izquierdo!=0)
mostrar(*arbol.hijo_izquierdo);
}

int main(){
struct arbol_binario arbol;
struct arbol_binario hoja1;
hoja1.valor=1;
hoja1.hijo_derecho=0;
hoja1.hijo_izquierdo=0;
hoja2.valor=2;
arbol.valor=0;
arbol.hijo_derecho=&hoja1;
arbol.hijo_izquierdo=&hoja2;
mostrar(arbol);
}
int main(){
struct arbol_binario arbol;
hoja1.valor=1;
hoja2.valor=2;
hoja2.hijo_izquierdo=&arbol;
arbol.valor=0;
arbol.hijo_derecho=&hoja1;
arbol.hijo_izquierdo=&hoja2;
mostrar(arbol);
}

struct alumno{
int rol;
char dig;
double notas[3];
};
double promedio(struct alumno a){
return (a.notas[0] + a.notas[1] +
a.notas[2])/3.0;
}

int main(){
struct alumno a;
a.rol=1;
a.dig='1';
a.notas[0]=55;
a.notas[1]=50;
a.notas[2]=61;
printf("Prom:
%.2fn",promedio(a));
}

Según lo expresado, las estructuras de decisión simple y doble permiten seleccionar entre dos
alternativas posibles. Sin embargo, la instrucción SI-ENTONCES puede ser utilizada también en casos
de selección de más de dos alternativas. Esto es posible anidando estas instrucciones. Es decir, una
estructura SI-ENTONCES puede contener a otra, y esta a su vez a otra. La representación en
pseudocódigo es la siguiente:
SI <condición_1> ENTONCES
< sentencias_1 >
SINO
< sentencias_2 >
SINO
< sentencias_3 >
SINO
.
.
FIN-SI
FIN-SI
FIN-SI
Estructura de selección. Sentencias anidadas.
Como se puede observar, el anidamiento de
instrucciones alternativas permite ir descartando
valores hasta llegar al bloque de instrucciones
que se debe ejecutar.
En las instrucciones SI anidadas, las
instrucciones ENTONCES y FIN-SI se aplican
automáticamente a la instrucción SI anterior más
próxima.
A fin de que las estructuras anidadas sean más
fáciles de leer, es práctica habitual aplicar sangría
al cuerpo de cada una.

Ejemplo: Un sensor toma (lee) la temperatura ambiente y de
acuerdo al rango en que se encuentre, debe emitir un mensaje.
La escala es la siguiente:
Mayor que 100 “Temperatura muy alta – Mal
funcionamiento”
Entre 91 y 100 “Rango normal”
Entre 51 y 90 “Bajo el rango normal”
Menor que 50 “Muy frío – Apague el equipo”
ALGORITMO Sensor
INICIO
LEER temperatura
SI temperatura > 100 ENTONCES
ESCRIBIR “Temperatura muy alta – Mal funcionamiento”
SINO
ESCRIBIR “Rango normal”
SINO
ESCRIBIR “Bajo el rango normal”
SINO
ESCRIBIR “Muy frío – Apague equipo”
FIN-SI
FIN-SI
FIN-SI
FIN

La sentencia IR-A (go to)
La sentencia GO TO pertenece a un grupo de sentencias conocidas como sentencias de salto
(jump). La característica de este grupo es hacer que el flujo de control salte a otra parte del
programa. Otras sentencias de este grupo son interrumpir o romper (BREAK), continuar
(CONTINUE), volver (RETURN), lanzar (THROW). Las dos primeras se utilizan generalmente con
sentencias de alternativa múltiple. Para retornar de la ejecución de funciones o métodos se usa
RETURN.
La sentencia GO TO se utilizaba mucho en los primeros lenguajes de programación porque era
la única manera de saltar de una instrucción del programa a otra.
Esta instrucción consta de una sentencia IR_A y una sentencia asociada con una etiqueta.
Cuando se ejecuta esta instrucción, se transfiere el control del programa a la etiqueta asociada.
Estructura de selección. Sentencias anidadas. Casos
Particulares

La representación en pseudocódigo es la siguiente:
INICIO
.
.
IR_A etiqueta_1
.
.
FIN
etiqueta_1:
. // El flujo salta aquí
El efecto de esta instrucción es transferir sin condiciones el control del programa a la etiqueta
especificada. Es una de las operaciones más primitivas para traspasar el control de una parte del
programa a otra. Sin embargo, su uso produce código inconsistente, incompleto o complicado de
mantener. Justamente por ello en los años 60 y 70, cuando surgió la programación estructurada, la
comunidad informática se expresó a favor de otras sentencias de control (IF ó bucles FOR y DO-
WHILE) en lugar del GOTO.
Casos Particulares

Tal creencia está tan arraigada que el GOTO es
muy criticado y desaconsejado por todos los que
se dedican a la enseñanza de la programación.
Si bien la instrucción GOTO puede parecer útil y
muy flexible, es precisamente en esa flexibilidad
donde radica su peligro y los motivos de su
obsolescencia.
6.5 Estructura de selección. Sentencias anidadas.
Casos Particulares

En un algoritmo puede existir y es muy frecuente que
existan 2 o más bucles. Dependiendo de la forma en
que estén dispuestos, estos pueden ser anidados o
independientes.
Decimos que los bucles están anidados cuando están
dispuestos de forma tal que unos son interiores a
otros; y los bucles serán independientes cuando son
extremos unos con otros.
Así como se podían anidar estructuras de selección,
también es posible insertar un bucle dentro de otro.
Las reglas para construir estructuras repetitivas
anidadas son iguales en ambos casos: la estructura
interna debe estar incluida totalmente dentro de la
externa y no puede existir solapamiento.
Diseño de bucles. Bucles Anidados

INDEPENDIENTES ANIDADAS
PERMITIDAS Y PROHIBIDAS
NIDOS CRUZADOS
SALIR DEL BUCLE ENTRAR AL BUCLE

ESTRUCTURAS ANIDADAS PRESENTACION

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a ESTRUCTURAS ANIDADAS PRESENTACION

Similar a ESTRUCTURAS ANIDADAS PRESENTACION (20)

Más de Carlos Gabriel Tipula Yanapa

Más de Carlos Gabriel Tipula Yanapa (13)

Último

Último (20)

ESTRUCTURAS ANIDADAS PRESENTACION