programación estructurada ii

UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
PROGRAMACIÓN ESTRUCTURADA II
Portafolio de Evidencias
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
Revisión de conceptos importantes
#include <conio.h>
#include <stdio.h>
ESTRUCTURAS
struct computadora{
float costo;
int anio;
int velocidad_cpu;
char tipo_cpu[16];
};modelo;
printf(“¿Tipo de CPU?”);
gets(modelo,tipo_cpu);
printf(“Velocidad”);
scanf(“%”,&modelo,velocidad,cpu);
INICIALIZADORES DE ESTRUCTURAS
struct empleados{
int id;
char nombre[32];};
struct empleados info={
I."B.Smit"};
PARA PASO DE ESTRUCTURA A UNA FUNCION
struct computadora{
float costo;
int anio;
];
typedef struct computadora EC;
EC Recibe Datos(ECS);
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
Rerencia a estructuras mediante apuntadores
struct computadora{
float costo;
int anio; };
typedef struct computadora EC;
void Recibe Datos (EC *aptr_s);
main (void){
EC modelo;
Recibe Datos (&modelo);
…}
void Recibe Datos(EC *aptr_s) {
printf(“CPU”);
gets(((*aptr_s).tipo_cpu));
printf(“Costo”);
scanf((“%d”,&)(*aptr_s);costo);
}
main(void)
{ EC modelo;
modelo=Recibe Datos (modelo);
printf(“Año:%d\n”,modelo.anio);
}
EC Recibe Datos (ECS)
{
printf(“Tipo de CPU”);
gets(S.Tipo_cpu);
return s;
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
APUNTADORES
Operador de dirección (&)
Ejemplo
long int x;
long int *y;
y=&x;
Ejemplo II
main()
{
char c;
int x;
float y;
c=’A’;
x=7;
y=123.45;
printf(“y: dirección=%p, contenidos=%s.2 fln”&y,y);
Salida
y: dirección =OX1AF6, contenido =123.4
Forma general para declarar un puntero tipo_de_dato * nombre_del_apuntador;
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
Ejemplo III
…
float y,*aptr_y;
…
y=123.45;
aptr_y=&y;
printf(“aptr_y: dirección: %p, contenido=%p,…&aptr_y,aptr_y”);
INDICAR LA SALIDA EN PANTALLA
int x, y, z;
int *aptr_1, *aptr_2, *aptr_3;
x=1234
printf (“%p,%d”, &x, x);
FFF0 1234
aptr_1=&x;
print (“%p, %p”, &aptr_1, aptr_1);
FFF3
FFF0
FFF4
FFF1
FFF5
1234
aptr_2=&y;
printf (“%p, %p”, &aptr_2, aptr_2);
aptr_3=aptr_1;
printf (“%p, %d”,&aptr_3,*aptr_3);
x
FFF0
y
FFF1
z
FFF2
aptr_1
FFF3
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
aptr_2
FFF4
aptr_3
FFF5
Malloc
Es una subrutina para el ejercicio asignación de memoria dinámica en los
lenguajes de programación C y C++ la función malloc sirve para solicitar un
bloque de memoria del tamaño suministrado como parámetro.
Sizeof
Se utiliza para copular los tamaños de tipos de datos sizeof se puede aplicar a
todos los tipos de datos ya sean tipos primitivos y de punto flotante de los
definidos de los punteros en direcciones de memoria.
LISTAS ENLAZADAS
Ejemplo
Crear una lista enlazada de elementos que almacenen datos de tipo entero.
1- struct Elemento {
int dato;
struct Elemento *siguiente; };
typedef struct Elemento Nodo;
2
Nodo*primero=NULL;
3
primero= (Nodo *) malloc (sizeof(Nodo));
4
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
primero-> dato=11;
primero-> siguiente=NULL;
5
nodo*crearnodo(int x,nodo* enlace)
{
nodo*p;
p=(nodo *) malloc (sizeof(nodo));
p->dato=x;
p->siguiente=enlace;
return p; }
INSERTAR DATO AL INICIO DE LISTA
void insertarcabezaLista (Nodo **cabeza, int entrada)
{
Nodo *nuevo;
nuevo = (Nodo *) malloc (sizeof (Nodo));
nuevo-> dato = entrada;
nuevo-> siguiente = *cabeza;
*cabeza = nuevo;
}
CREAR UNA LISTA DE DATOS
void insertarlista (Nodo **cabeza, int entrada)
{
Nodo *nuevo;
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
nuevo = (Nodo*) malloc (sizeof (Nodo));
nuevo->dato=entrada;
nuevo-> siguiente = anterior -> siguiente;
anterior ->siguiente = nuevo;
}
INSERTAR DATO AL FINAL DE LA LISTA
void insertarlistafinal (Nodo **cabeza, int entrada)
{
Nodo *nuevo;
nuevo=(Nodo *) malloc (sizeof (Nodo));
nuevo-> dato = entrada;
nuevo-> siguiente = NULL;
final-> siguiente = nuevo;
}
ELIMINAR UN DATO
void suprime(Nodo **primero,int dato1)
{
Nodo *ptr,*ant;
int enc=0;
ptr=*primero;
int=ptr;
while((!enc)&&(ptr!=NULL))
{
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
enc=(ptr->dato=dato1),
if(!enc)
{
ant=ptr;
ptr=ptr->siguiente;
}
}
if(ptr!=NULL)
{
if(ptr==*primero)
*primero=ptr->siguiente;
else
anterior->siguiente=ptr->siguiente;
free(ptr);
}
}
INGRESAR UN DATO
void ingresar2 (Nodo **primero, int dato1)
{
Nodo *nuevo,*anterior,*p;
nuevo=nuevoNodo(dato1);
if(*primero=NULL)
*primero=nuevo;
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
else
if(dato1<=(*primero)->dato)
{
nuevo->siguiente=*primero;
*primero=nuevo;
}
else
{
anterior=p=*primero;
while((dato>p->dato)&&(p->siguiente!=NULL))
{
anterior=p;
p=p->siguiente;
}
if(dato1>p->dato)
ant=p;
nuevo->siguiente=anterior->siguiente;
anterior->siguiente=nuevo;
}
}
LISTAS DOBLEMENTE ENLAZADAS
struct unnodo
{
int dato;
UBAM
UNIVERSIDAD BANCARIA DE MEXICO
“Constancia, Unidad y Trabajo”
García Cabrera Ma. de Jesús
Programación Estructurada II – Prof. Juan Carlos Martínez
struct unnodo *adelante;
struct unnodo *atras;
};
typedef struct unnodo nodo;
Inserción de un elemento en una lista doblemente enlazada
nodo*nuevo;
nuevo=(nodo *) malloc (sizeof(nodo));
nuevo->dato=entrada;
nuevo->adelante=primero;
nuevo->anterior=NULL;
primero->anterior=nuevo;
primero=nuevo;
nodo *nuevo2;
nuevo2=(nodo *) malloc (sizeof(nodo));
nuevo2->dato=entrada2;
nuevo2->siguiente=nuevo;
nuevo2->anterior=NULL;
primero->anterior=nuevo2;
primero=nuevo2;
UBAM